The main namespace for the Muto engine. More...

Namespaces
namespace	Color
	Provides commonly used colors and color manipulation functions.

namespace	Key
	Namespace for keyboard key codes.

namespace	Math
	Contains mathematical utility functions for the Vesper engine.

namespace	Math2D

namespace	Mouse
	Namespace for mouse button codes.

namespace	Random

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

struct	ApplicationSettings
	Holds configuration settings for the application. More...

class	AppRenderEvent
	Event for registering application render. More...

class	AppTickEvent
	Event for registering application tick. More...

class	AppUpdateEvent
	Event for registering application update. More...

struct	BufferElement
	Represents a single element in a buffer layout. More...

class	BufferLayout
	Represents the layout of a buffer, consisting of multiple BufferElements. More...

class	Camera
	The base Camera class that all Camera's derive from Only contains a pojection matrix and a getter. More...

struct	CameraComponent
	Component that holds camera data. More...

class	EditorCamera

class	EditorLayer

class	Entity
	Represents an entity in a scene. More...

class	Event
	Abstract base class for all events. More...

class	EventDispatcher
	Stack-based templated event dispatcher. More...

class	FileDialogs
	Cross-platform file dialog utilities. More...

class	FileSystem
	WIP. More...

class	Framebuffer
	Abstract class representing a framebuffer. More...

struct	FramebufferSpecification
	Specification for creating a Framebuffer. More...

class	GraphicsContext
	Abstract class representing a graphics context. More...

class	ImGuiLayer

class	IndexBuffer
	Abstract base class for an index buffer. More...

class	Input
	Base input class for querying input states. More...

struct	InstrumentationSession

class	InstrumentationTimer

class	Instrumentor

class	KeyEvent
	Base class for keyboard events. More...

class	KeyPressedEvent
	Event for registering key press. More...

class	KeyReleasedEvent
	Event for registering key release. More...

class	KeyTypedEvent
	Event for registering key typing. More...

class	Layer
	Represents a reusable application layer that receives lifecycle callbacks (attach, detach, update, events, render, and ImGui render). Intended as a base class for concrete layers. More...

class	LayerStack
	Manages an ordered stack of Layer pointers. Layers can be pushed or popped and the stack can be iterated in forward or reverse order. More...

class	Log
	A logging utility class for the Vesper engine. More...

class	MouseButtonEvent
	Base class for mouse button events. More...

class	MouseButtonPressedEvent
	Event for registering mouse button presses. More...

class	MouseButtonReleasedEvent
	Event for registering mouse button releases. More...

class	MouseMovedEvent
	Event for registering mouse movement. More...

class	MouseScrolledEvent
	Event for registering mouse scroll wheel movement. More...

class	Mutare

struct	MutoResult

struct	NameComponent
	Component that holds the name of an entity. More...

struct	NativeScriptComponent
	Component that holds scripting data for an entity. More...

class	OpenGLContext

class	OpenGLFramebuffer

class	OpenGLImGuiLayer

class	OpenGLIndexBuffer

class	OpenGLRendererAPI
	An implementation of the RenderAPI for OpenGL. More...

class	OpenGLShader

class	OpenGLTexture2D

class	OpenGLUniformBuffer

class	OpenGLVertexArray

class	OpenGLVertexBuffer

class	OrthographicCamera

struct	OrthographicCameraBounds

class	OrthographicCameraController

struct	Particle

struct	ParticleProps

class	ParticleSystem
	A simple particle system for stress testing the renderer. This is a temporary starter particle system and will be replaced with a more robust implementation in the future. More...

struct	ParticleSystemComponent

struct	ProfileResult

struct	QuadVertex
	Represents a single vertex in a quad, containing position, color, texture coordinates, texture index, and tiling factor. More...

class	RenderAPI
	An abstract class defining the interface for a rendering API. More...

class	RenderCommand
	A static class that provides an interface for issuing rendering commands. More...

class	Renderer
	The main renderer class responsible for managing rendering operations. More...

class	Renderer2D
	A 2D renderer for drawing quads and sprites. More...

struct	Renderer2DData
	Contains all the internal data and resources used by the Renderer2D, such as vertex arrays, buffers, shaders, textures, and rendering statistics. More...

class	ResourceManager
	The ResourceManager class is responsible for managing application resources and pathing. More...

class	Scene
	Represents a scene in the application and manages entities and their components. More...

class	SceneCamera

class	SceneHierarchyPanel

class	SceneSerializer
	Handles serialization and deserialization of scenes. More...

class	ScriptableEntity
	Base class for scriptable entities within a scene. More...

class	Shader
	An abstraction for a shader program. More...

class	ShaderLibrary
	A library for managing and storing shaders. More...

struct	SpriteRendererComponent
	Component that holds sprite rendering data. More...

class	SubTexture2D
	Represents a sub-region of a 2D texture, useful for sprite sheets. More...

struct	SubTextureComponent
	Component that holds sub-texture data for sprites. More...

class	Texture
	An abstraction for a texture. More...

class	Texture2D
	An abstraction for a 2D texture. More...

struct	TextureAnimationComponent
	Animates through a series of sub textures. More...

class	TextureLibrary
	A library for managing and storing textures. More...

class	Timestep
	Represents a time step in seconds. More...

struct	TransformComponent
	Component that holds the transform of an entity. More...

class	UniformBuffer
	An abstraction for a uniform buffer object (UBO). More...

struct	UUID
	Universally Unique Identifier. More...

struct	UUIDComponent
	Component that holds a UUID. More...

class	VertexArray
	An abstraction for a vertex array object (VAO). More...

class	VertexBuffer
	Abstract base class for a vertex buffer. More...

class	Window
	Abstract interface representing an application window. More...

class	WindowCloseEvent
	Event for registering window close. More...

struct	WindowProps
	Holds the data for window configuration. More...

class	WindowResizeEvent
	Event for registering window resize. More...

class	WindowsWindow

Typedefs
using	FloatingPointMicroseconds = std::chrono::duration< double, std::micro >

using	KeyCode = uint16_t
	Alias for keyboard key code type.

using	MouseButtonCodes = uint8_t
	Alias for mouse button code type.

template<typename T >
using	Ref = std::shared_ptr< T >
	A smart pointer type representing shared ownership of an object.

template<typename T >
using	Scope = std::unique_ptr< T >
	A smart pointer type representing exclusive ownership of an object.

Enumerations
enum	EventCategory { EC_None = 0 , EC_Application = BIT(0) , EC_Input = BIT(1) , EC_Keyboard = BIT(2) , EC_Mouse = BIT(3) , EC_MouseButton = BIT(4) }
	Enumeration of event categories. More...

enum class	EventType { ET_None = 0 , ET_WindowClose , ET_WindowResize , ET_WindowFocus , ET_WindowLostFocus , ET_WindowMoved , ET_AppTick , ET_AppUpdate , ET_AppRender , ET_KeyPressed , ET_KeyReleased , ET_KeyTyped , ET_MouseButtonPressed , ET_MouseButtonReleased , ET_MouseMoved , ET_MouseScrolled }
	Enumeration of event types. More...

enum class	MU_RETURN { SUCCESS = 0 , FAILURE , FILE_NOT_FOUND , INVALID_ARGUMENT , OUT_OF_MEMORY , UNKNOWN_ERROR }

enum class	PathResolveMode { WorkingDirectory , ProjectDirectory , AssetsDirectory }
	Specifies the mode for resolving resource paths in the application. More...

enum class	ShaderDataType { SDT_None = 0 , SDT_Float , SDT_Float2 , SDT_Float3 , SDT_Float4 , SDT_Mat3 , SDT_Mat4 , SDT_Int , SDT_Int2 , SDT_Int3 , SDT_Int4 , SDT_Bool }
	The different data types that can be used in shaders. More...

enum class	WindowMode { Windowed = 0 , Fullscreen = 1 , Borderless = 2 }
	WIP. More...

Functions
Application *	CreateApplication ()

template<typename T , typename... Args>
constexpr Ref< T >	CreateRef (Args &&... args)
	Creates a Ref (shared_ptr) for the given type and constructor arguments.

template<typename T , typename... Args>
constexpr Scope< T >	CreateScope (Args &&... args)
	Creates a Scope (unique_ptr) for the given type and constructor arguments.

template<typename T , typename UIFunction >
static void	DrawComponent (const std::string &name, Entity entity, UIFunction uiFunction)

static void	DrawVec2Control (const std::string &label, glm::vec2 &values, float resetValue=0.0f, float columnWidth=100.0f)

static void	DrawVec3Control (const std::string &label, glm::vec3 &values, float resetValue=0.0f, float columnWidth=100.0f)

std::string	format_as (const Event &e)
	Format an event as a string.

static void	GLFWErrorCallback (int error, const char *description)

static bool	IsAbsolutePath (const std::string &path)
	Determines whether the given path is an absolute path (Unix-style, Windows-style, or drive-letter).

static std::string	JoinPaths (const std::string &base, const std::string &relative)
	Joins two path segments with proper separator handling.

static std::string	NormalizePath (const std::string &path)
	Normalizes path separators to forward slashes for cross-platform consistency.

static void	SerializeEntity (YAML::Emitter &out, Entity entity)

static uint32_t	ShaderDataTypeSize (ShaderDataType type)
	Returns the size in bytes of the given ShaderDataType.

static GLenum	ShaderDataTypeToOpenGLBaseType (ShaderDataType type)

static GLenum	ShaderTypeFromString (const std::string &type)

static void	SubTextureEdit (Entity entity, const std::string &label, SubTextureComponent &subTexture)

static void	TextureAnimationEdit (const std::string &label, SubTextureComponent &subTexture, TextureAnimationComponent &texAnim)

Variables
static Renderer2DData	s_Data

static bool	s_GLFWInitialized = false

static const uint32_t	s_MaxFramebufferSize = 8192
	TODO: Get the actual maximum size from the GPU!

Detailed Description

The main namespace for the Muto engine.

Temporary.

Todo:: Remove GLFW include once abstracted

Todo:: Abstract this class to OpenGL/DirectX/Vulkan etc ImGui layers

Todo:: Remove GLFW include once abstracted

Todo:: Abstract this class to OpenGL/DirectX/Vulkan etc ImGui layers

Class Documentation

◆ Muto::ApplicationSettings

struct Muto::ApplicationSettings

Holds configuration settings for the application.

Class Members
string	ApplicationName = "Muto Application"	The name of the application.
string	AssetsDirectory	The assets directory of the application.
bool	EnableImGui = true	Flag indicating whether ImGui is enabled for the application.
bool	EnableVSync = false	Flag indicating whether vertical synchronization (VSync) is enabled for the application.
GFile	FileSystem	The file system interface for the application.
uint32_t	Height = 720	The height of the application window.
WindowMode	Mode = WindowMode::Windowed	The window mode of the application (e.g., windowed, fullscreen, borderless).
string	ProjectDirectory	The project directory of the application.
API	RendererAPIType = RenderAPI::API::RAPI_OpenGL	The renderer API to use for the application.
uint32_t	Width = 1280	The width of the application window.
string	WorkingDirectory	The working directory of the application.

◆ Muto::FramebufferSpecification

struct Muto::FramebufferSpecification

Specification for creating a Framebuffer.

Class Members
uint32_t	Height
uint32_t	Samples = 1
bool	SwapChainTarget = false
uint32_t	Width

◆ Muto::InstrumentationSession

struct Muto::InstrumentationSession

Class Members
string	Name

◆ Muto::Particle

struct Muto::Particle

Class Members
bool	Active = false
vec4	ColorBegin
vec4	ColorEnd
float	LifeRemaining = 0.0f
float	Lifetime = 0.0f
vec3	Position
float	Rotation
float	SizeBegin
float	SizeEnd
vec3	Velocity

◆ Muto::ParticleProps

struct Muto::ParticleProps

Class Members
vec4	ColorBegin = { 1.0f, 1.0f, 1.0f, 1.0f }
vec4	ColorEnd = { 1.0f, 1.0f, 1.0f, 1.0f }
float	Lifetime = 1.0f
float	LifetimeVariation = 0.0f
vec3	Position = { 0.0f, 0.0f, 0.0f }
vec3	PositionVariation = { 0.0f, 0.0f, 0.0f }
float	Rotation = 0.0f
float	RotationVariation = 0.0f
float	SizeBegin = 1.0f
float	SizeEnd = 0.0f
float	SizeVariation = 0.0f
vec3	Velocity = { 0.0f, 0.0f, 0.0f }
vec3	VelocityVariation = { 0.0f, 0.0f, 0.0f }

◆ Muto::ProfileResult

struct Muto::ProfileResult

Class Members
long long	End
string	Name
long long	Start
uint32_t	ThreadID

◆ Muto::QuadVertex

struct Muto::QuadVertex

Represents a single vertex in a quad, containing position, color, texture coordinates, texture index, and tiling factor.

Todo:: move to Geometry dir

Todo:: move to Geometry dir

Class Members
vec4	Color
vec3	Position
vec2	TexCoord
float	TexIndex
float	TilingFactor

Typedef Documentation

◆ FloatingPointMicroseconds

using Muto::FloatingPointMicroseconds = typedef std::chrono::duration<double, std::micro>

◆ KeyCode

using Muto::KeyCode = typedef uint16_t

Alias for keyboard key code type.

◆ MouseButtonCodes

using Muto::MouseButtonCodes = typedef uint8_t

Alias for mouse button code type.

◆ Ref

template<typename T >

using Muto::Ref = typedef std::shared_ptr<T>

A smart pointer type representing shared ownership of an object.

Template Parameters

T	The type of object to manage.

Note: This is an alias for std::shared_ptr.

◆ Scope

template<typename T >

using Muto::Scope = typedef std::unique_ptr<T>

A smart pointer type representing exclusive ownership of an object.

Template Parameters

T	The type of object to manage.

Note: This is an alias for std::unique_ptr.

Enumeration Type Documentation

◆ EventCategory

enum Muto::EventCategory

Enumeration of event categories.

Enumerator
EC_None
EC_Application
EC_Input
EC_Keyboard
EC_Mouse
EC_MouseButton

    {
        EC_None = 0,
        EC_Application  = BIT(0),
        EC_Input        = BIT(1),
        EC_Keyboard     = BIT(2),
        EC_Mouse        = BIT(3),
        EC_MouseButton  = BIT(4)
    };

◆ EventType

enum class Muto::EventType

strong

Enumeration of event types.

Enumerator
ET_None
ET_WindowClose
ET_WindowResize
ET_WindowFocus
ET_WindowLostFocus
ET_WindowMoved
ET_AppTick
ET_AppUpdate
ET_AppRender
ET_KeyPressed
ET_KeyReleased
ET_KeyTyped
ET_MouseButtonPressed
ET_MouseButtonReleased
ET_MouseMoved
ET_MouseScrolled

    {
        ET_None = 0,
        ET_WindowClose, ET_WindowResize, ET_WindowFocus, ET_WindowLostFocus, ET_WindowMoved,
        ET_AppTick, ET_AppUpdate, ET_AppRender,
        ET_KeyPressed, ET_KeyReleased, ET_KeyTyped,
        ET_MouseButtonPressed, ET_MouseButtonReleased, ET_MouseMoved, ET_MouseScrolled
    };

◆ MU_RETURN

enum class Muto::MU_RETURN

strong

Enumerator
SUCCESS
FAILURE
FILE_NOT_FOUND
INVALID_ARGUMENT
OUT_OF_MEMORY
UNKNOWN_ERROR

    {
        SUCCESS = 0,
        FAILURE,
        FILE_NOT_FOUND,
        INVALID_ARGUMENT,
        OUT_OF_MEMORY,
        UNKNOWN_ERROR
    };

◆ PathResolveMode

enum class Muto::PathResolveMode

strong

Specifies the mode for resolving resource paths in the application.

Enumerator
WorkingDirectory
ProjectDirectory
AssetsDirectory

                               {
        WorkingDirectory,
        ProjectDirectory,
        AssetsDirectory
    };

◆ ShaderDataType

enum class Muto::ShaderDataType

strong

The different data types that can be used in shaders.

Enumerator
SDT_None
SDT_Float
SDT_Float2
SDT_Float3
SDT_Float4
SDT_Mat3
SDT_Mat4
SDT_Int
SDT_Int2
SDT_Int3
SDT_Int4
SDT_Bool

                              {
        SDT_None = 0,
        SDT_Float, SDT_Float2, SDT_Float3, SDT_Float4,
        SDT_Mat3, SDT_Mat4,
        SDT_Int, SDT_Int2, SDT_Int3, SDT_Int4,
        SDT_Bool
    };

◆ WindowMode

enum class Muto::WindowMode

strong

WIP.

Enumerator
Windowed
Fullscreen
Borderless

    {
        Windowed = 0,
        Fullscreen = 1,
        Borderless = 2
    };

Function Documentation

◆ CreateApplication()

Muto::Application * Muto::CreateApplication ( )

{
    ApplicationSettings settings;
    settings.ApplicationName = "Sandbox";
 
    //settings.WorkingDirectory = "";
    settings.ProjectDirectory = "";
    settings.AssetsDirectory = ("Muto/src/Editor/assets");
 
    settings.RendererAPIType = RenderAPI::API::RAPI_OpenGL;
    settings.Width = 1600;
    settings.Height = 900;
    settings.Mode = WindowMode::Windowed;
    settings.EnableImGui = true;
    settings.EnableVSync = true;
 
    //return new SandboxApp(); 
    return new SandboxApp(settings);
}

References Muto::ApplicationSettings::AssetsDirectory, Muto::ApplicationSettings::EnableImGui, Muto::ApplicationSettings::EnableVSync, Muto::ApplicationSettings::Height, Muto::ApplicationSettings::Mode, Muto::ApplicationSettings::ProjectDirectory, Muto::RenderAPI::RAPI_OpenGL, Muto::ApplicationSettings::RendererAPIType, SandboxApp::SandboxApp(), Muto::ApplicationSettings::Width, and Windowed.

◆ CreateRef()

template<typename T , typename... Args>

constexpr Ref< T > Muto::CreateRef ( Args &&... args )

constexpr

Creates a Ref (shared_ptr) for the given type and constructor arguments.

Template Parameters

T	The type of object to create.
Args	The types of constructor arguments.

Parameters

args	The constructor arguments.

Returns: A Ref (shared_ptr) managing the created object.

    {
        return std::make_shared<T>(std::forward<Args>(args)...);
    }

◆ CreateScope()

template<typename T , typename... Args>

constexpr Scope< T > Muto::CreateScope ( Args &&... args )

constexpr

Creates a Scope (unique_ptr) for the given type and constructor arguments.

Template Parameters

T	The type of object to create.
Args	The types of constructor arguments.

Parameters

args	The constructor arguments.

Returns: A Scope (unique_ptr) managing the created object.

    {
        return std::make_unique<T>(std::forward<Args>(args)...);
    }

◆ DrawComponent()

template<typename T , typename UIFunction >

static void Muto::DrawComponent	(	const std::string &	name,
		Entity	entity,
		UIFunction	uiFunction
	)

static

    {
        const ImGuiTreeNodeFlags treeNodeFlags = ImGuiTreeNodeFlags_DefaultOpen | ImGuiTreeNodeFlags_Framed | ImGuiTreeNodeFlags_SpanAvailWidth | ImGuiTreeNodeFlags_AllowItemOverlap | ImGuiTreeNodeFlags_FramePadding;
        if (entity.HasComponent<T>())
        {
            auto& component = entity.GetComponent<T>();
            ImVec2 contentRegionAvailable = ImGui::GetContentRegionAvail();
 
            ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2{ 4, 4 });
            float lineHeight = ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f;
            ImGui::Separator();
            bool open = ImGui::TreeNodeEx((void*)typeid(T).hash_code(), treeNodeFlags, name.c_str());
            ImGui::PopStyleVar(
            );
            ImGui::SameLine(contentRegionAvailable.x - lineHeight * 0.5f);
            if (ImGui::Button("+", ImVec2{ lineHeight, lineHeight }))
            {
                ImGui::OpenPopup("ComponentSettings");
            }
 
            bool removeComponent = false;
            if (ImGui::BeginPopup("ComponentSettings"))
            {
                if (ImGui::MenuItem("Remove component"))
                    removeComponent = true;
 
                ImGui::EndPopup();
            }
 
            if (open)
            {
                uiFunction(entity, component);
                ImGui::TreePop();
            }
 
            if (removeComponent)
                entity.RemoveComponent<T>();
        }
    }

◆ DrawVec2Control()

static void Muto::DrawVec2Control	(	const std::string &	label,
		glm::vec2 &	values,
		float	resetValue = `0.0f`,
		float	columnWidth = `100.0f`
	)

static

    {
        ImGuiIO& io = ImGui::GetIO();
        auto boldFont = io.Fonts->Fonts[0];
 
        ImGui::PushID(label.c_str());
 
        ImGui::Columns(2);
        ImGui::SetColumnWidth(0, columnWidth);
        ImGui::Text(label.c_str());
        ImGui::NextColumn();
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{ 0, 0 });
 
        float lineHeight = ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f;
        ImVec2 buttonSize = { lineHeight + 3.0f, lineHeight };
 
        // Compute available width for the three float controls in the right column
        float availableWidth = ImGui::GetContentRegionAvail().x;
        float itemSpacing = ImGui::GetStyle().ItemSpacing.x;
        float totalButtonWidth = buttonSize.x * 2.0f;
        // Account for SameLine() spacings between button+control pairs (conservative estimate)
        float totalSpacing = itemSpacing * 4.0f;
        float itemWidth = (availableWidth - totalButtonWidth - totalSpacing) / 2.0f;
        if (itemWidth <= 0.0f)
            itemWidth = ImGui::CalcItemWidth();
 
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.8f, 0.1f, 0.15f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.9f, 0.2f, 0.2f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.8f, 0.1f, 0.15f, 1.0f });
        ImGui::PushFont(boldFont);
        if (ImGui::Button("X", buttonSize))
            values.x = resetValue;
        ImGui::PopFont();
        ImGui::PopStyleColor(3);
 
        ImGui::SameLine();
        ImGui::PushItemWidth(itemWidth);
        ImGui::DragFloat("##X", &values.x, 0.1f, 0.0f, 0.0f, "%.2f");
        ImGui::PopItemWidth();
        ImGui::SameLine();
 
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.2f, 0.7f, 0.2f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.3f, 0.8f, 0.3f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.2f, 0.7f, 0.2f, 1.0f });
        ImGui::PushFont(boldFont);
        if (ImGui::Button("Y", buttonSize))
            values.y = resetValue;
        ImGui::PopFont();
        ImGui::PopStyleColor(3);
 
        ImGui::SameLine();
        ImGui::PushItemWidth(itemWidth);
        ImGui::DragFloat("##Y", &values.y, 0.1f, 0.0f, 0.0f, "%.2f");
        ImGui::PopItemWidth();
        ImGui::SameLine();
 
        ImGui::PopStyleVar();
 
        ImGui::Columns(1);
 
        ImGui::PopID();
    }

◆ DrawVec3Control()

static void Muto::DrawVec3Control	(	const std::string &	label,
		glm::vec3 &	values,
		float	resetValue = `0.0f`,
		float	columnWidth = `100.0f`
	)

static

    {
        ImGuiIO& io = ImGui::GetIO();
        auto boldFont = io.Fonts->Fonts[0];
 
        ImGui::PushID(label.c_str());
 
        ImGui::Columns(2);
        ImGui::SetColumnWidth(0, columnWidth);
        ImGui::Text(label.c_str());
        ImGui::NextColumn();
 
        ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2{ 0, 0 });
 
        float lineHeight = ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2.0f;
        ImVec2 buttonSize = { lineHeight + 3.0f, lineHeight };
 
        // Compute available width for the three float controls in the right column
        float availableWidth = ImGui::GetContentRegionAvail().x;
        float itemSpacing = ImGui::GetStyle().ItemSpacing.x;
        float totalButtonWidth = buttonSize.x * 3.0f;
        // Account for SameLine() spacings between button+control pairs (conservative estimate)
        float totalSpacing = itemSpacing * 6.0f;
        float itemWidth = (availableWidth - totalButtonWidth - totalSpacing) / 3.0f;
        if (itemWidth <= 0.0f)
            itemWidth = ImGui::CalcItemWidth();
 
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.8f, 0.1f, 0.15f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.9f, 0.2f, 0.2f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.8f, 0.1f, 0.15f, 1.0f });
        ImGui::PushFont(boldFont);
        if (ImGui::Button("X", buttonSize))
            values.x = resetValue;
        ImGui::PopFont();
        ImGui::PopStyleColor(3);
 
        ImGui::SameLine();
        ImGui::PushItemWidth(itemWidth);
        ImGui::DragFloat("##X", &values.x, 0.1f, 0.0f, 0.0f, "%.2f");
        ImGui::PopItemWidth();
        ImGui::SameLine();
 
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.2f, 0.7f, 0.2f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.3f, 0.8f, 0.3f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.2f, 0.7f, 0.2f, 1.0f });
        ImGui::PushFont(boldFont);
        if (ImGui::Button("Y", buttonSize))
            values.y = resetValue;
        ImGui::PopFont();
        ImGui::PopStyleColor(3);
 
        ImGui::SameLine();
        ImGui::PushItemWidth(itemWidth);
        ImGui::DragFloat("##Y", &values.y, 0.1f, 0.0f, 0.0f, "%.2f");
        ImGui::PopItemWidth();
        ImGui::SameLine();
 
        ImGui::PushStyleColor(ImGuiCol_Button, ImVec4{ 0.1f, 0.25f, 0.8f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4{ 0.2f, 0.35f, 0.9f, 1.0f });
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4{ 0.1f, 0.25f, 0.8f, 1.0f });
        ImGui::PushFont(boldFont);
        if (ImGui::Button("Z", buttonSize))
            values.z = resetValue;
        ImGui::PopFont();
        ImGui::PopStyleColor(3);
 
        ImGui::SameLine();
        ImGui::PushItemWidth(itemWidth);
        ImGui::DragFloat("##Z", &values.z, 0.1f, 0.0f, 0.0f, "%.2f");
        ImGui::PopItemWidth();
 
        ImGui::PopStyleVar();
 
        ImGui::Columns(1);
 
        ImGui::PopID();
    }

◆ format_as()

std::string Muto::format_as ( const Event & e )

inline

Format an event as a string.

    {
        return e.ToString();
    }

References Muto::Event::ToString().

◆ GLFWErrorCallback()

static void Muto::GLFWErrorCallback	(	int	error,
		const char *	description
	)

static

    {
        MU_CORE_ERROR("GLFW Error ({0}): {1}", error, description);
    }

Referenced by Muto::WindowsWindow::Init().

◆ IsAbsolutePath()

static bool Muto::IsAbsolutePath ( const std::string & path )

static

Determines whether the given path is an absolute path (Unix-style, Windows-style, or drive-letter).

    {
        if (path.empty())
            return false;
 
        if (path[0] == '/' || path[0] == '\\')
            return true;
 
        if (path.size() > 1 && path[1] == ':')
            return true;
 
        return false;
    }

Referenced by Muto::Application::InitFileSystem(), Muto::Application::ResolvePath_AssetsDirectory(), Muto::Application::ResolvePath_ProjectDirectory(), and Muto::Application::ResolvePath_WorkingDirectory().

◆ JoinPaths()

static std::string Muto::JoinPaths	(	const std::string &	base,
		const std::string &	relative
	)

static

Joins two path segments with proper separator handling.

    {
        if (base.empty())
            return relative;
        if (relative.empty())
            return base;
 
        std::string result = base;
        
        // Ensure base doesn't end with a separator
        if (result.back() == '/' || result.back() == '\\')
            result.pop_back();
 
        result += '/';
        
        // Append relative path, removing leading separators
        size_t start = 0;
        while (start < relative.size() && (relative[start] == '/' || relative[start] == '\\'))
            start++;
        
        result += relative.substr(start);
        return result;
    }

Referenced by Muto::Renderer2D::Init(), and Muto::Application::InitFileSystem().

◆ NormalizePath()

static std::string Muto::NormalizePath ( const std::string & path )

static

Normalizes path separators to forward slashes for cross-platform consistency.

    {
        std::string normalized = path;
        for (char& c : normalized)
        {
            if (c == '\\')
                c = '/';
        }
        return normalized;
    }

Referenced by Muto::Application::InitFileSystem(), Muto::Application::ResolvePath_AssetsDirectory(), Muto::Application::ResolvePath_ProjectDirectory(), and Muto::Application::ResolvePath_WorkingDirectory().

◆ SerializeEntity()

static void Muto::SerializeEntity	(	YAML::Emitter &	out,
		Entity	entity
	)

static

                                                                 {
 
        MU_CORE_ASSERT(entity.HasComponent<UUIDComponent>(), "Entity has no UUIDComponent!");
        MU_CORE_ASSERT(entity.HasComponent<NameComponent>(), "Entity has no NameComponent!");
 
        out << YAML::BeginMap; // Entity
        out << YAML::Key << "Entity" << YAML::Value << entity.GetID(); // UUIDComponent
        out << YAML::Key << "NameComponent" << YAML::Value << entity.GetName();
 
        if (entity.HasComponent<TransformComponent>()) {
            out << YAML::Key << "TransformComponent";
            out << YAML::BeginMap; // TransformComponent
 
            auto& tc = entity.GetComponent<TransformComponent>();
            out << YAML::Key << "Translation" << YAML::Value << tc.Translation;
            out << YAML::Key << "Rotation" << YAML::Value << tc.Rotation;
            out << YAML::Key << "Scale" << YAML::Value << tc.Scale;
 
            out << YAML::EndMap; // TransformComponent
        }
 
        if (entity.HasComponent<CameraComponent>()) {
            out << YAML::Key << "CameraComponent";
            out << YAML::BeginMap; // CameraComponent
 
            auto& cameraComp = entity.GetComponent<CameraComponent>();
            auto& camera = cameraComp.Camera;
 
 
            out << YAML::Key << "Camera" << YAML::Value;
            out << YAML::BeginMap; // Camera
            out << YAML::Key << "PerspectiveFOV" << YAML::Value << camera.GetPerspectiveVerticalFOV();
            out << YAML::Key << "PerspectiveNear" << YAML::Value << camera.GetPerspectiveNearClip();
            out << YAML::Key << "PerspectiveFar" << YAML::Value << camera.GetPerspectiveFarClip();
            out << YAML::Key << "OrthographicSize" << YAML::Value << camera.GetOrthographicSize();
            out << YAML::Key << "OrthographicNear" << YAML::Value << camera.GetOrthographicNearClip();
            out << YAML::Key << "OrthographicFar" << YAML::Value << camera.GetOrthographicFarClip();
            out << YAML::EndMap;
 
            out << YAML::Key << "Primary" << YAML::Value << cameraComp.Primary;
            out << YAML::Key << "ProjectionType" << YAML::Value << (int)camera.GetProjectionType();
            out << YAML::Key << "FixedAspectRatio" << YAML::Value << cameraComp.FixedAspectRatio;
 
            out << YAML::EndMap; // CameraComponent
        }
 
        if (entity.HasComponent<SpriteRendererComponent>()) {
            out << YAML::Key << "SpriteRendererComponent";
            out << YAML::BeginMap; // SpriteRendererComponent
 
            auto& src = entity.GetComponent<SpriteRendererComponent>();
            out << YAML::Key << "Color" << YAML::Value << src.Color;
            // Texture serialization can be added here in the future
            out << YAML::EndMap; // SpriteRendererComponent
        }
        out << YAML::EndMap; // Entity
    }

◆ ShaderDataTypeSize()

static uint32_t Muto::ShaderDataTypeSize ( ShaderDataType type )

static

Returns the size in bytes of the given ShaderDataType.

Parameters

type	The ShaderDataType to get the size of.

Returns: The size in bytes of the ShaderDataType. Will assert if the type is unknown.

                                                            {
        switch (type) {
        case ShaderDataType::SDT_Float:     return 4;
        case ShaderDataType::SDT_Float2:    return 4 * 2;
        case ShaderDataType::SDT_Float3:    return 4 * 3;
        case ShaderDataType::SDT_Float4:    return 4 * 4;
        case ShaderDataType::SDT_Mat3:      return 4 * 3 * 3;
        case ShaderDataType::SDT_Mat4:      return 4 * 4 * 4;
        case ShaderDataType::SDT_Int:       return 4;
        case ShaderDataType::SDT_Int2:      return 4 * 2;
        case ShaderDataType::SDT_Int3:      return 4 * 3;
        case ShaderDataType::SDT_Int4:      return 4 * 4;
        case ShaderDataType::SDT_Bool:      return 1;
        }
        MU_CORE_ASSERT(false, "Unknown ShaderDataType!");
        return 0;
    }

References SDT_Bool, SDT_Float, SDT_Float2, SDT_Float3, SDT_Float4, SDT_Int, SDT_Int2, SDT_Int3, SDT_Int4, SDT_Mat3, and SDT_Mat4.

Referenced by Muto::BufferElement::BufferElement().

◆ ShaderDataTypeToOpenGLBaseType()

static GLenum Muto::ShaderDataTypeToOpenGLBaseType ( ShaderDataType type )

static

    {
        switch (type)
        {
        case ShaderDataType::SDT_Float:     return GL_FLOAT;
        case ShaderDataType::SDT_Float2:    return GL_FLOAT;
        case ShaderDataType::SDT_Float3:    return GL_FLOAT;
        case ShaderDataType::SDT_Float4:    return GL_FLOAT;
        case ShaderDataType::SDT_Mat3:      return GL_FLOAT;
        case ShaderDataType::SDT_Mat4:      return GL_FLOAT;
        case ShaderDataType::SDT_Int:       return GL_INT;
        case ShaderDataType::SDT_Int2:      return GL_INT;
        case ShaderDataType::SDT_Int3:      return GL_INT;
        case ShaderDataType::SDT_Int4:      return GL_INT;
        case ShaderDataType::SDT_Bool:      return GL_BOOL;
        }
        MU_CORE_ASSERT(false, "Unknown ShaderDataType!");
        return 0;
    }

◆ ShaderTypeFromString()

static GLenum Muto::ShaderTypeFromString ( const std::string & type )

static

    {
        MU_PROFILE_FUNCTION();
        if (type == "vertex")
            return GL_VERTEX_SHADER;
        if (type == "fragment" || type == "pixel")
            return GL_FRAGMENT_SHADER;
        MU_CORE_ASSERT(false, "Unknown shader type!");
        return 0;
    }

Referenced by Muto::OpenGLShader::PreProcess().

◆ SubTextureEdit()

static void Muto::SubTextureEdit	(	Entity	entity,
		const std::string &	label,
		SubTextureComponent &	subTexture
	)

static

    {
        ImGui::Text(label.c_str());
 
        auto& subTexRef = subTexture.GetSubTexture();
        if (subTexRef && subTexRef->GetTexture()) {
            auto oldSubRef = subTexRef;
            glm::vec2 oldOffset = subTexture.Offset;
            glm::vec2 oldTiling = subTexture.TilingFactor;
 
            DrawVec2Control("Offset", subTexture.Offset);
            DrawVec2Control("Scale", subTexture.TilingFactor, 1.0f);
 
            if (subTexRef->GetTexture())
            {
                auto tex = subTexRef->GetTexture();
                if (tex) {
 
                    auto newSub = SubTexture2D::CreateFromCoords(
                        tex, subTexture.Offset,
                        glm::vec2(static_cast<float>(tex->GetWidth()) * subTexture.TilingFactor.x,
                            static_cast<float>(tex->GetHeight()) * subTexture.TilingFactor.y));
                    subTexture.SubTexture = newSub;
 
                    if (entity.HasComponent<TextureAnimationComponent>()) {
                        auto& texAnim = entity.GetComponent<TextureAnimationComponent>();
                        for (auto& frame : texAnim.SubTextures) {
                            // frame == oldSubRef compares Ref<> identity
                            if (frame == oldSubRef) {
                                frame = newSub;
                            }
                        }
 
                        if (texAnim.CurrentFrame >= (int)texAnim.SubTextures.size())
                            texAnim.CurrentFrame = texAnim.SubTextures.empty() ? 0 : (int)texAnim.SubTextures.size() - 1;
                    }
                }
            }
        }
        else {
            ImGui::Text("No texture assigned.");
        }
 
    }

◆ TextureAnimationEdit()

static void Muto::TextureAnimationEdit	(	const std::string &	label,
		SubTextureComponent &	subTexture,
		TextureAnimationComponent &	texAnim
	)

static

                                                                                                                                  {
        ImGui::Text(label.c_str());
 
        auto& subTexRef = subTexture.GetSubTexture();
        if (subTexRef && subTexRef->GetTexture()) {
            glm::vec2 oldOffset = subTexture.Offset;
            glm::vec2 oldTiling = subTexture.TilingFactor;
 
            DrawVec2Control("Offset", subTexture.Offset);
            DrawVec2Control("Scale", subTexture.TilingFactor, 1.0f);
 
            if (subTexRef->GetTexture())
            {
                auto tex = subTexRef->GetTexture();
                if (tex) {
 
                    if (ImGui::Button("Add SubTexture to Animation")) {
                        bool skip = false;
                        for (int i = 0; i < texAnim.SubTextures.size(); i++) {
                            if (texAnim.SubTextures[i] == subTexture.GetSubTexture()) {
                                MU_CORE_WARN("Sub Texture already stored in array. Skipping addition");
                                skip = true;
                                break;
                            }
                        }
                        if (!skip) {
                            texAnim.SubTextures.push_back(subTexture.GetSubTexture());
                        }
                    }
                    if (ImGui::Button("Override Current Frame")) {
                        if (texAnim.SubTextures.size() == 0) {
                            MU_CORE_WARN("No frames to override.");
                        }
                        else {
                            if (texAnim.CurrentFrame < 0 || texAnim.CurrentFrame >= (int)texAnim.SubTextures.size())
                                texAnim.CurrentFrame = 0;
                            texAnim.SubTextures[texAnim.CurrentFrame] = SubTexture2D::CreateFromCoords(tex, subTexture.Offset,
                                glm::vec2(static_cast<float>(tex->GetWidth()) * subTexture.TilingFactor.x,
                                    static_cast<float>(tex->GetHeight()) * subTexture.TilingFactor.y));
                        }
                    }
                    if (ImGui::Button("Remove Current Frame")) {
 
                        if (texAnim.SubTextures.size() <= 1) {
                            return;
                        }
 
                        int idx = texAnim.CurrentFrame;
                        if (idx < 0) idx = 0;
                        if (idx >= (int)texAnim.SubTextures.size()) idx = (int)texAnim.SubTextures.size() - 1;
 
                        texAnim.SubTextures.erase(texAnim.SubTextures.begin() + idx);
                        MU_CORE_INFO("Animation Frame removed successfully!");
 
                        if (texAnim.SubTextures.empty())
                            texAnim.CurrentFrame = 0;
                        else if (texAnim.CurrentFrame >= (int)texAnim.SubTextures.size())
                            texAnim.CurrentFrame = 0;
                    }
                }
            }
        }
        else {
            ImGui::Text("No texture assigned.");
        }
    }

References Muto::TextureAnimationComponent::CurrentFrame.

Variable Documentation

◆ s_Data

static Renderer2DData Muto::s_Data

static

◆ s_GLFWInitialized

static bool Muto::s_GLFWInitialized = false

static

Referenced by Muto::WindowsWindow::Init().

◆ s_MaxFramebufferSize

static const uint32_t Muto::s_MaxFramebufferSize = 8192

static

TODO: Get the actual maximum size from the GPU!

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Class Documentation

◆ Muto::ApplicationSettings

◆ Muto::FramebufferSpecification

◆ Muto::InstrumentationSession

◆ Muto::Particle

◆ Muto::ParticleProps

◆ Muto::ProfileResult

◆ Muto::QuadVertex

Typedef Documentation

◆ FloatingPointMicroseconds

◆ KeyCode

◆ MouseButtonCodes

◆ Ref

◆ Scope

Enumeration Type Documentation

◆ EventCategory

◆ EventType

◆ MU_RETURN

◆ PathResolveMode

◆ ShaderDataType

◆ WindowMode

Function Documentation

◆ CreateApplication()

◆ CreateRef()

◆ CreateScope()

◆ DrawComponent()

◆ DrawVec2Control()

◆ DrawVec3Control()

◆ format_as()

◆ GLFWErrorCallback()

◆ IsAbsolutePath()

◆ JoinPaths()

◆ NormalizePath()

◆ SerializeEntity()

◆ ShaderDataTypeSize()

◆ ShaderDataTypeToOpenGLBaseType()

◆ ShaderTypeFromString()

◆ SubTextureEdit()

◆ TextureAnimationEdit()

Variable Documentation

◆ s_Data

◆ s_GLFWInitialized

◆ s_MaxFramebufferSize