Muto::EditorLayer Class Reference

#include <EditorLayer.h>

Inheritance diagram for Muto::EditorLayer:

Public Member Functions
	EditorLayer ()
virtual void	OnAttach () override
	Called when the layer is attached to the application.
virtual void	OnDetach () override
	Called when the layer is detached from the application.
virtual void	OnEvent (Event &e) override
	Called when an event is dispatched to the layer.
virtual void	OnImGuiRender () override
	Called when the layer should render its ImGui components.
virtual void	OnUpdate (Timestep ts) override
	Called every frame to update the layer with the given timestep.
virtual	~EditorLayer ()=default
Public Member Functions inherited from Muto::Layer
const std::string &	GetName () const
	Retrieves the name of the layer for debugging purposes.
	Layer (const std::string &name="Layer")
	Constructs a Layer with an optional name for debugging purposes.
virtual void	OnRender ()
	Called when the layer should render its contents.
virtual	~Layer ()

Private Types
enum class	SceneState { Edit = 0 , Play = 1 , Simulate = 2 }

Private Member Functions
void	NewScene ()
bool	OnKeyPressed (KeyPressedEvent &e)
void	OpenScene ()
void	ResetScene ()
void	SaveSceneAs ()

Private Attributes
float	lastFrameTime = 0.0f
Ref< Scene >	m_ActiveScene
glm::vec4	m_BackgroundColor = { 0.1f, 0.1f, 0.1f, 1.0f }
OrthographicCameraController	m_CameraController
Entity	m_CameraEntity
Ref< Texture2D >	m_CheckerboardTexture
glm::vec4	m_ClearColor = { 0.1f, 0.3f, 0.3f, 1.0f }
EditorCamera	m_EditorCamera
Ref< Scene >	m_EditorScene
Entity	m_FireEntity
Ref< Shader >	m_FlatColorShader
Ref< Framebuffer >	m_Framebuffer
int	m_GizmoType = -1
int	m_ParticleEmitCount = 100
ParticleProps	m_ParticleProps
ParticleSystem	m_ParticleSystem
bool	m_PrimaryCamera = true
float	m_RotationSnap = 45.0f
float	m_ScaleSnap = 0.5f
SceneHierarchyPanel	m_SceneHierarchyPanel
SceneState	m_SceneState = SceneState::Edit
Entity	m_SmokeEntity
glm::vec4	m_SpecialQuadColor = { 0.9f, 0.2f, 0.8f, 1.0f }
float	m_specialQuadRotation = 0.5f
Ref< Texture2D >	m_SpriteSheetCrystals
Ref< Texture2D >	m_SpriteSheetCursedLands
Ref< Texture2D >	m_SpriteSheetFire
Ref< Texture2D >	m_SpriteSheetRocks
Ref< Texture2D >	m_SpriteSheetSmoke
Ref< Texture2D >	m_SpriteSheetTown
glm::vec4	m_SquareColor = { 0.2f, 0.3f, 0.8f, 1.0f }
float	m_squareRotation = 25.0f
Ref< VertexArray >	m_SquareVA
Ref< SubTexture2D >	m_SubTextureFire
Ref< SubTexture2D >	m_SubTextureSmoke
Ref< SubTexture2D >	m_SubTextureTown
float	m_textureScale = 1.0f
glm::vec4	m_TextureTintColor1 = { 1.0f, 1.0f, 1.0f, 1.0f }
glm::vec4	m_TextureTintColor2 = { 1.0f, 1.0f, 1.0f, 1.0f }
float	m_TranslationSnap = 0.5f
bool	m_UseSpecialQuadColor = false
glm::vec2	m_ViewportBounds [2] = { {0,0}, {0,0} }
bool	m_ViewportFocused = false
bool	m_ViewportHovered = false
glm::vec2	m_ViewportSize = {0,0}
std::unordered_map< char, Ref< SubTexture2D > >	s_TextureMap
bool	scene1 = false
bool	scene2 = false
bool	scene3 = false
bool	scene4 = false
bool	useEntityScene = true

Additional Inherited Members
Protected Attributes inherited from Muto::Layer
std::string	m_DebugName
	The name of the layer assigned at creation, used for debugging.

Member Enumeration Documentation

SceneState

enum class Muto::EditorLayer::SceneState

strongprivate

Enumerator
Edit
Play
Simulate

        {
            Edit = 0, Play = 1, Simulate = 2
        };

Constructor & Destructor Documentation

EditorLayer()

Muto::EditorLayer::EditorLayer

(

)

        : Layer("Sandbox2D"), m_CameraController(1280.0f / 720.0f, true)
    {
        MU_PROFILE_FUNCTION();
    }

References EditorLayer().

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

~EditorLayer()

virtual Muto::EditorLayer::~EditorLayer ( )

virtualdefault

Member Function Documentation

NewScene()

void Muto::EditorLayer::NewScene ( )

private

    {
        m_ActiveScene = CreateRef<Scene>();
        m_ActiveScene->OnViewportResize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);
        m_SceneHierarchyPanel.SetContext(m_ActiveScene);
    }

Referenced by OnImGuiRender(), and OnKeyPressed().

OnAttach()

void Muto::EditorLayer::OnAttach ( )

overridevirtual

Called when the layer is attached to the application.

TODO: move to resource manager TODO: fix pathing

TODO: Get an automatic path to resource that is NOT hardcoded

TODO: move to resource manager TODO: fix pathing

TODO: Get an automatic path to resource that is NOT hardcoded

Reimplemented from Muto::Layer.

    {
        MU_PROFILE_FUNCTION();
 
        // Texture / SubTexture setup
        {
            m_CheckerboardTexture = Texture2D::Create("Muto/src/Editor/assets/textures/Checkerboard.png");
            m_SpriteSheetFire = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/fire_01.png");
            m_SpriteSheetSmoke = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/fire_02.png");
            m_SpriteSheetTown = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/town_tilesheet.png");
            m_SpriteSheetCrystals = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/craftpix/Crystals/Crystals.png");
            m_SpriteSheetRocks = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/craftpix/Rocks/Rocks_source.png");
            m_SpriteSheetCursedLands = Texture2D::Create("Muto/src/Editor/assets/textures/sheets/craftpix/CursedLand/Tiled_files/Objects.png");
 
            m_SubTextureFire = SubTexture2D::CreateFromCoords(m_SpriteSheetFire, { 1, 0 }, { 128, 127 });
            m_SubTextureSmoke = SubTexture2D::CreateFromCoords(m_SpriteSheetSmoke, { 1, 0 }, { 128, 127 });
            m_SubTextureTown = SubTexture2D::CreateFromCoords(m_SpriteSheetTown, { 4.25, 0.75 }, { 64, 64 }, { 1, 1 });
            s_TextureMap['F'] = SubTexture2D::CreateFromCoords(m_SpriteSheetFire, { 1, 0 }, { 128, 127 });
            s_TextureMap['G'] = SubTexture2D::CreateFromCoords(m_SpriteSheetTown, { 4.25, 0.75 }, { 64, 64 }, { 1, 1 });
            s_TextureMap['C'] = SubTexture2D::CreateFromCoords(m_SpriteSheetCrystals, { 0, 1.25 }, { 64, 64 }, { 1, 1 });
            s_TextureMap['R'] = SubTexture2D::CreateFromCoords(m_SpriteSheetRocks, { 0, 3.75 }, { 64, 64 }, { 1, 1 });
            s_TextureMap['P'] = SubTexture2D::CreateFromCoords(m_SpriteSheetCursedLands, { 0, 1.875 }, { 128, 128 }, { 1, 1 });
        }
 
 
        // Particle setup
        {
            m_ParticleProps.Position = { 0.0f, 0.0f, 0.0f };
            m_ParticleProps.Velocity = { 0.0f, 0.0f, 0.0f };
            m_ParticleProps.VelocityVariation = { 1.0f, 1.0f, 0.0f };
            m_ParticleProps.ColorBegin = { 1.0f, 0.5f, 0.2f, 1.0f };
            m_ParticleProps.ColorEnd = { 0.2f, 0.3f, 0.8f, 1.0f };
            m_ParticleProps.SizeBegin = 0.5f;
            m_ParticleProps.SizeEnd = 0.0f;
            m_ParticleProps.Lifetime = 3.0f;
            m_ParticleProps.Rotation = 0.0f;
            m_ParticleProps.RotationVariation = 27.0f;
            m_ParticleSystem = ParticleSystem(10000);
            m_ParticleSystem.SetParticleProps(m_ParticleProps);
        }
 
        // Framebuffer/Viewport setup
        {
            FramebufferSpecification fbSpec;
            fbSpec.Width = 1280;
            fbSpec.Height = 720;
            m_Framebuffer = Framebuffer::Create(fbSpec);
        }
 
        // Scene setup
        {
            //m_CameraController.SetZoomLevel(5.5f);
            m_ActiveScene = CreateRef<Scene>();
 
#if 0
            m_CameraEntity = m_ActiveScene->CreateEntity("Primary Camera Entity");
 
            auto& pCam = m_CameraEntity.AddComponent<CameraComponent>();
            pCam.Primary = true;
            pCam.Camera.SetPerspective(glm::radians(45.0f), 0.1f, 1000.0f);
            auto& pos = m_CameraEntity.GetComponent<TransformComponent>().Translation;
            pos.x += 1.25f;
            pos.z += 5.0f;
 
            auto fbSpec = m_Framebuffer->GetSpecification();
            m_ActiveScene->OnViewportResize(fbSpec.Width, fbSpec.Height);
 
            // Animation 1
            {
                auto square = m_ActiveScene->CreateEntity("Fire Animation");
                auto& transform = square.GetComponent<TransformComponent>();
                transform.Translation = (glm::vec3(-0.5f, 0.0f, -1.5f));
 
                square.AddComponent<SpriteRendererComponent>(glm::vec4{ 0.8f, 0.8f, 0.2f, 1.0f });
                std::vector<Ref<SubTexture2D>> fireFrames;
                for (int x = 0; x < 63; x++)
                {
                    for (int y = 0; y < 2; y++)
                    {
                        fireFrames.push_back(SubTexture2D::CreateFromCoords(m_SpriteSheetFire, { (float)y, (float)x }, { 128, 128 }));
                    }
                }
                TextureAnimationComponent texAnim(fireFrames, 0.05f);
                square.AddComponent<TextureAnimationComponent>(texAnim);
                m_FireEntity = square;
            }
 
            // Animation 2
            {
                auto square = m_ActiveScene->CreateEntity("Smoke Animation");
                auto& transform = square.GetComponent<TransformComponent>();
                // adjust the position of the square entity
                transform.Translation = (glm::vec3(0.5f, 0.0f, 1.5f));
 
                square.AddComponent<SpriteRendererComponent>(glm::vec4{ 0.8f, 0.8f, 0.2f, 1.0f });
                std::vector<Ref<SubTexture2D>> smokeFrames;
                for (int x = 0; x < 63; x++)
                {
                    for (int y = 0; y < 2; y++)
                    {
                        smokeFrames.push_back(SubTexture2D::CreateFromCoords(m_SpriteSheetSmoke, { (float)y, (float)x }, { 128, 128 }));
                    }
 
                }
                TextureAnimationComponent texAnim(smokeFrames, 0.05f);
                square.AddComponent<TextureAnimationComponent>(texAnim);
                m_SmokeEntity = square;
            }
 
            auto quadEntity = m_ActiveScene->CreateEntity("Quad Entity");
            quadEntity.AddComponent<SpriteRendererComponent>(glm::vec4{ 0.2f, 0.3f, 0.8f, 1.0f });
            quadEntity.GetComponent<TransformComponent>().Scale = { 0.5f, 0.5f, 1.0f };
            quadEntity.GetComponent<TransformComponent>().Translation = { 1.5f, 0.0f, 0.0f };
 
 
            class CameraController : public ScriptableEntity {
            public:
                void OnCreate()
                {
                    GetComponent<TransformComponent>().Translation = (glm::vec3(Random::RangeF1(-3.0f, 3.0f), Random::RangeF1(-3.0f, 3.0f), 0.0f));
 
                }
 
                void OnDestroy()
                {
 
                }
 
                void OnUpdate(Timestep ts)
                {
                    auto& transform = GetComponent<TransformComponent>().GetTransform();
                    float speed = 5.0f;
 
 
                    if (Input::IsKeyPressed(VZ_KEY_A))
                        transform[3][0] -= speed * ts;
 
                    if (Input::IsKeyPressed(VZ_KEY_D))
                        transform[3][0] += speed * ts;
 
                    if (Input::IsKeyPressed(VZ_KEY_W))
                        transform[3][1] += speed * ts;
 
                    if (Input::IsKeyPressed(VZ_KEY_S))
                        transform[3][1] -= speed * ts;
                }
 
            };
 
            m_CameraEntity.AddComponent<NativeScriptComponent>().Bind<CameraController>();
            m_SecondaryCameraEntity.AddComponent<NativeScriptComponent>().Bind<CameraController>();
 
#endif
 
            m_SceneHierarchyPanel.SetContext(m_ActiveScene);
 
            SceneSerializer serializer(m_ActiveScene);
 
            FileSystem::Initialize();
 
            if (MU_EDITOR_USE_DEFAULT_SCENE) {
                std::string loadedScene = FileSystem::GetAbsolutePath(MU_EDITOR_DEFAULT_SCENE);
 
                bool valid = serializer.Deserialize(loadedScene);
                if (!valid) {
                    MU_CORE_ERROR("Failed to load default scene: " + loadedScene);
                    MU_CORE_ERROR("Attempted Scene: " + std::string(MU_EDITOR_DEFAULT_SCENE));
                    MU_CORE_ERROR("Current Working Directory: " + FileSystem::GetCurrentWorkingDirectory());
                    MU_CORE_ERROR("Absolute Path Attempted: " + FileSystem::GetAbsolutePath(loadedScene));
                    MU_CORE_ERROR("Error loading the scene, please check the paths and file availability.");
                }
                else {
                    MU_CORE_INFO("Successfully loaded the default scene: " + loadedScene);
                }
            }
            m_EditorCamera = EditorCamera(30.0f, 1.778f, 0.1f, 1000.0f);
        }
 
 
    }

References Muto::SceneSerializer::Deserialize(), Muto::FileSystem::GetAbsolutePath(), Muto::FileSystem::GetCurrentWorkingDirectory(), Muto::FramebufferSpecification::Height, Muto::FileSystem::Initialize(), and Muto::FramebufferSpecification::Width.

OnDetach()

void Muto::EditorLayer::OnDetach ( )

overridevirtual

Called when the layer is detached from the application.

Reimplemented from Muto::Layer.

    {
        MU_PROFILE_FUNCTION();
    }

OnEvent()

void Muto::EditorLayer::OnEvent ( Event &  event )

overridevirtual

Called when an event is dispatched to the layer.

Parameters

event

The event being dispatched.

Reimplemented from Muto::Layer.

    {
        m_CameraController.OnEvent(e);
        if (m_SceneState == SceneState::Edit) {
            m_EditorCamera.OnEvent(e);
        }
 
        EventDispatcher dispatcher(e);
        dispatcher.Dispatch<KeyPressedEvent>(MU_BIND_EVENT_FN(EditorLayer::OnKeyPressed));
 
    }

References Edit, Muto::EventDispatcher::EventDispatcher(), m_SceneState, and OnKeyPressed().

OnImGuiRender()

void Muto::EditorLayer::OnImGuiRender ( )

overridevirtual

Called when the layer should render its ImGui components.

Reimplemented from Muto::Layer.

    {
        MU_PROFILE_FUNCTION();
 
        static bool dockspaceOpen = true;
        static bool opt_fullscreen = true;
        static bool opt_padding = false;
        static ImGuiDockNodeFlags dockspace_flags = ImGuiDockNodeFlags_None;
 
        // We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
        // because it would be confusing to have two docking targets within each others.
        ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar | ImGuiWindowFlags_NoDocking;
        if (opt_fullscreen)
        {
            const ImGuiViewport* viewport = ImGui::GetMainViewport();
            ImGui::SetNextWindowPos(viewport->WorkPos);
            ImGui::SetNextWindowSize(viewport->WorkSize);
            ImGui::SetNextWindowViewport(viewport->ID);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
            ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
            window_flags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove;
            window_flags |= ImGuiWindowFlags_NoBringToFrontOnFocus | ImGuiWindowFlags_NoNavFocus;
        }
 
        // When using ImGuiDockNodeFlags_PassthruCentralNode, DockSpace() will render our background
        // and handle the pass-thru hole, so we ask Begin() to not render a background.
        if (dockspace_flags & ImGuiDockNodeFlags_PassthruCentralNode)
            window_flags |= ImGuiWindowFlags_NoBackground;
 
        // Important: note that we proceed even if Begin() returns false (aka window is collapsed).
        // This is because we want to keep our DockSpace() active. If a DockSpace() is inactive,
        // all active windows docked into it will lose their parent and become undocked.
        // We cannot preserve the docking relationship between an active window and an inactive docking, otherwise
        // any change of dockspace/settings would lead to windows being stuck in limbo and never being visible.
        if (!opt_padding)
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
        ImGui::Begin("DockSpace Demo", &dockspaceOpen, window_flags);
        if (!opt_padding)
            ImGui::PopStyleVar();
 
        if (opt_fullscreen)
            ImGui::PopStyleVar(2);
 
        // Submit the DockSpace
        ImGuiIO& io = ImGui::GetIO();
        ImGuiStyle& style = ImGui::GetStyle();
        float minWinSize = style.WindowMinSize.x = 370.0f;
 
        if (io.ConfigFlags & ImGuiConfigFlags_DockingEnable)
        {
            ImGuiID dockspace_id = ImGui::GetID("MyDockSpace");
            ImGui::DockSpace(dockspace_id, ImVec2(0.0f, 0.0f), dockspace_flags);
        }
 
        style.WindowMinSize.x = minWinSize;
 
        if (ImGui::BeginMenuBar())
        {
            if (ImGui::BeginMenu("File"))
            {
                // Disabling fullscreen would allow the window to be moved to the front of other windows,
                // which we can't undo at the moment without finer window depth/z control.
 
                if (ImGui::MenuItem("New", "Ctrl+N"))
                    NewScene();
 
 
                if (ImGui::MenuItem("Open..", "Ctrl+O"))
                    OpenScene();
 
 
                if (ImGui::MenuItem("Save As..", "Ctrl+Shift+S"))
                    SaveSceneAs();
 
 
                if (ImGui::MenuItem("Reset Scene"))
                    ResetScene();
 
 
                if (ImGui::MenuItem("Exit"))
                    Muto::Application::Get().Close();
 
                ImGui::EndMenu();
            }
 
            ImGui::EndMenuBar();
        }
 
        m_SceneHierarchyPanel.OnImGuiRender();
 
        {
            ImGui::Begin("Settings");
            ImGui::Text("Renderer2D Stats:");
            auto stats = Renderer2D::GetStats();
            ImGui::Text("\tDraw Calls: %d", stats.DrawCalls);
            ImGui::Text("\tQuad Count: %d", stats.QuadCount);
            ImGui::Text("\tVertex Count: %d", stats.GetTotalVertexCount());
            ImGui::Text("\tIndex Count: %d", stats.GetTotalIndexCount());
            ImGui::Text("Application Settings:");
            ImGui::Text("\tFPS: %.1f", ImGui::GetIO().Framerate);
            if (ImGui::ColorEdit4("Background Color", glm::value_ptr(m_ClearColor)))
            {
                RenderCommand::SetClearColor(m_ClearColor);
            }
            ImGui::End();
        }
 
        {
            ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2{ 0,0 });
            ImGui::Begin("Viewport");
            m_ViewportFocused = ImGui::IsWindowFocused();
            m_ViewportHovered = ImGui::IsWindowHovered();
            Application::Get().GetImGuiLayer()->SetBlockEvents(!m_ViewportFocused && !m_ViewportHovered);
 
            ImVec2 viewportPanelSize = ImGui::GetContentRegionAvail();
            if (m_ViewportSize != *((glm::vec2*)&viewportPanelSize) && viewportPanelSize.x > 0.0f && viewportPanelSize.y > 0)
            {
                m_Framebuffer->Resize((uint32_t)viewportPanelSize.x, (uint32_t)viewportPanelSize.y);
                m_ViewportSize = { viewportPanelSize.x, viewportPanelSize.y };
 
                m_CameraController.OnResize(viewportPanelSize.x, viewportPanelSize.y);
            }
 
            ImVec2 viewportBoundsMin = ImGui::GetCursorScreenPos();
            ImVec2 viewportBoundsMax = { viewportBoundsMin.x + m_ViewportSize.x, viewportBoundsMin.y + m_ViewportSize.y };
            m_ViewportBounds[0] = { viewportBoundsMin.x, viewportBoundsMin.y };
            m_ViewportBounds[1] = { viewportBoundsMax.x, viewportBoundsMax.y };
 
            uint32_t textureID = m_Framebuffer->GetColorAttachmentRendererID();
            ImGui::Image(textureID, ImVec2(m_ViewportSize.x, m_ViewportSize.y), ImVec2(0, 1), ImVec2(1, 0));
 
            // Gizmos
            Entity selectedEntity = m_SceneHierarchyPanel.GetSelectedEntity();
            if (selectedEntity && m_GizmoType != -1)
            {
                ImGuizmo::SetOrthographic(false);
                ImGuizmo::SetDrawlist();
                float windowWidth = (float)ImGui::GetWindowWidth();
                float windowHeight = (float)ImGui::GetWindowHeight();
                ImGuizmo::SetRect(ImGui::GetWindowPos().x, ImGui::GetWindowPos().y, windowWidth, windowHeight);
 
                // Camera
                // Runtime camera from entity
                //auto cameraEntity = m_ActiveScene->GetPrimaryCameraEntity();
                //const auto& camera = cameraEntity.GetComponent<CameraComponent>().Camera;
                //const glm::mat4& cameraProjection = camera.GetProjection();
                //glm::mat4 cameraView = glm::inverse(cameraEntity.GetComponent<TransformComponent>().GetTransform());
 
                // Editor camera
                const glm::mat4& cameraProjection = m_EditorCamera.GetProjection();
                glm::mat4 cameraView = m_EditorCamera.GetViewMatrix();
 
                // Entity Transform
                auto& tc = selectedEntity.GetComponent<TransformComponent>();
                glm::mat4 transform = tc.GetTransform();
 
                // Snapping
                bool snap = Input::IsKeyPressed(Key::LeftControl);
                // use the editor layer snap values
                float snapValue = m_TranslationSnap;
                if (m_GizmoType == ImGuizmo::OPERATION::ROTATE)
                    snapValue = m_RotationSnap;
                else if (m_GizmoType == ImGuizmo::OPERATION::SCALE)
                    snapValue = m_ScaleSnap;
 
                float snapValues[3] = { snapValue, snapValue, snapValue };
 
                ImGuizmo::Manipulate(glm::value_ptr(cameraView), glm::value_ptr(cameraProjection),
                    (ImGuizmo::OPERATION)m_GizmoType, ImGuizmo::LOCAL, glm::value_ptr(transform),
                    nullptr, snap ? snapValues : nullptr);
 
                if (ImGuizmo::IsUsing())
                {
                    glm::vec3 translation, rotation, scale;
                    Muto::Math::DecomposeTransform(transform, translation, rotation, scale);
                    tc.Translation = translation;
                    tc.Rotation = rotation;
                    tc.Scale = scale;
                }
            }
 
            ImGui::End();
            ImGui::PopStyleVar();
        }
        ImGui::End();
    }

References Muto::Application::Close(), Muto::Application::Get(), Muto::Application::GetImGuiLayer(), Muto::Renderer2D::GetStats(), Muto::Input::IsKeyPressed(), Muto::Key::LeftControl, m_GizmoType, m_RotationSnap, m_ScaleSnap, m_TranslationSnap, m_ViewportFocused, m_ViewportHovered, NewScene(), OpenScene(), ResetScene(), SaveSceneAs(), and Muto::ImGuiLayer::SetBlockEvents().

OnKeyPressed()

bool Muto::EditorLayer::OnKeyPressed ( KeyPressedEvent &  e )

private

    {
        // Shortcuts
        if (e.GetRepeatCount() > 0)
            return false;
 
        bool control = Input::IsKeyPressed(Key::LeftControl) || Input::IsKeyPressed(Key::RightControl);
        bool shift = Input::IsKeyPressed(Key::LeftShift) || Input::IsKeyPressed(Key::RightShift);
        switch (e.GetKeyCode())
        {
            // Scene Shortcuts
        case Key::N:
 
            if (control)
            {
                NewScene();
            }
            break;
 
        case Key::O:
            if (control)
            {
                OpenScene();
            }
            break;
 
        case Key::S:
            if (control && shift)
            {
                SaveSceneAs();
            }
            break;
 
 
            // Gizmo Shortcuts
        case Key::Q:
            m_GizmoType = -1;
            break;
        case Key::W:
            m_GizmoType = ImGuizmo::OPERATION::TRANSLATE;
            break;
        case Key::E:
            m_GizmoType = ImGuizmo::OPERATION::ROTATE;
            break;
        case Key::R:
            m_GizmoType = ImGuizmo::OPERATION::SCALE;
            break;
        }
        return false;
 
    }

References Muto::KeyEvent::GetKeyCode(), Muto::KeyPressedEvent::GetRepeatCount(), Muto::Input::IsKeyPressed(), Muto::Key::LeftControl, Muto::Key::LeftShift, m_GizmoType, Muto::Key::N, NewScene(), Muto::Key::O, OpenScene(), Muto::Key::Q, Muto::Key::RightControl, Muto::Key::RightShift, Muto::Key::S, and SaveSceneAs().

Referenced by OnEvent().

OnUpdate()

void Muto::EditorLayer::OnUpdate ( Timestep  ts )

overridevirtual

Called every frame to update the layer with the given timestep.

Parameters

ts	The timestep representing the time elapsed since the last update.

Reimplemented from Muto::Layer.

    {
        MU_PROFILE_FUNCTION();
 
        // Resize
        if (Muto::FramebufferSpecification spec = m_Framebuffer->GetSpecification();
            m_ViewportSize.x > 0.0f && m_ViewportSize.y > 0.0f &&
            (spec.Width != (uint32_t)m_ViewportSize.x || spec.Height != (uint32_t)m_ViewportSize.y))
        {
            m_Framebuffer->Resize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);
            m_CameraController.OnResize(m_ViewportSize.x, m_ViewportSize.y);
            m_EditorCamera.SetViewportSize(m_ViewportSize.x, m_ViewportSize.y);
            m_ActiveScene->OnViewportResize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);
        }
 
        // Update
        if (m_ViewportFocused)
        {
            m_CameraController.OnUpdate(ts);
        }
            m_EditorCamera.OnUpdate(ts);
 
 
        // Render
        Renderer2D::ResetStats();
        {
            MU_PROFILE_SCOPE("Renderer Prep");
            m_Framebuffer->Bind();
            RenderCommand::SetClearColor(m_ClearColor);
            RenderCommand::Clear();
        }
 
 
        // Draw
        {
            {
                MU_PROFILE_SCOPE("Entity Scene Update");
                // Update scene
                    m_ActiveScene->OnUpdateRuntime(ts);
                    m_ActiveScene->OnUpdateEditor(ts, m_EditorCamera);
            }
        }
 
        m_Framebuffer->Unbind();
    }

References Muto::RenderCommand::Clear(), m_ViewportFocused, and Muto::Renderer2D::ResetStats().

OpenScene()

void Muto::EditorLayer::OpenScene ( )

private

    {
        std::string filePath = FileDialogs::OpenFile("Vesper Scene (*.vesper)\0*.vesper\0");
 
        if (!filePath.empty())
        {
            m_ActiveScene = CreateRef<Scene>();
            m_ActiveScene->OnViewportResize((uint32_t)m_ViewportSize.x, (uint32_t)m_ViewportSize.y);
            m_SceneHierarchyPanel.SetContext(m_ActiveScene);
 
            SceneSerializer serializer(m_ActiveScene);
            serializer.Deserialize(filePath);
            MU_CORE_INFO("Scene deserialized from: " + filePath);
        }
    }

References Muto::SceneSerializer::Deserialize(), and Muto::FileDialogs::OpenFile().

Referenced by OnImGuiRender(), and OnKeyPressed().

ResetScene()

void Muto::EditorLayer::ResetScene ( )

private

    {
        MU_CORE_ASSERT(false, "Not implemented yet!");
    }

Referenced by OnImGuiRender().

SaveSceneAs()

void Muto::EditorLayer::SaveSceneAs ( )

private

    {
        std::string filePath = FileDialogs::SaveFile("Vesper Scene (*.vesper)\0*.vesper\0");
        if (!filePath.empty())
        {
            SceneSerializer serializer(m_ActiveScene);
            serializer.Serialize(filePath);
            MU_CORE_INFO("Scene serialized to: " + filePath);
        }
    }

References Muto::FileDialogs::SaveFile(), and Muto::SceneSerializer::Serialize().

Referenced by OnImGuiRender(), and OnKeyPressed().

Member Data Documentation

lastFrameTime

float Muto::EditorLayer::lastFrameTime = 0.0f

private

m_ActiveScene

Ref<Scene> Muto::EditorLayer::m_ActiveScene

private

m_BackgroundColor

glm::vec4 Muto::EditorLayer::m_BackgroundColor = { 0.1f, 0.1f, 0.1f, 1.0f }

private

{ 0.1f, 0.1f, 0.1f, 1.0f };

m_CameraController

OrthographicCameraController Muto::EditorLayer::m_CameraController

private

m_CameraEntity

Entity Muto::EditorLayer::m_CameraEntity

private

m_CheckerboardTexture

Ref<Texture2D> Muto::EditorLayer::m_CheckerboardTexture

private

m_ClearColor

glm::vec4 Muto::EditorLayer::m_ClearColor = { 0.1f, 0.3f, 0.3f, 1.0f }

private

{ 0.1f, 0.3f, 0.3f, 1.0f };

m_EditorCamera

EditorCamera Muto::EditorLayer::m_EditorCamera

private

m_EditorScene

Ref<Scene> Muto::EditorLayer::m_EditorScene

private

m_FireEntity

Entity Muto::EditorLayer::m_FireEntity

private

m_FlatColorShader

Ref<Shader> Muto::EditorLayer::m_FlatColorShader

private

m_Framebuffer

Ref<Framebuffer> Muto::EditorLayer::m_Framebuffer

private

m_GizmoType

int Muto::EditorLayer::m_GizmoType = -1

private

Referenced by OnImGuiRender(), and OnKeyPressed().

m_ParticleEmitCount

int Muto::EditorLayer::m_ParticleEmitCount = 100

private

m_ParticleProps

ParticleProps Muto::EditorLayer::m_ParticleProps

private

m_ParticleSystem

ParticleSystem Muto::EditorLayer::m_ParticleSystem

private

m_PrimaryCamera

bool Muto::EditorLayer::m_PrimaryCamera = true

private

m_RotationSnap

float Muto::EditorLayer::m_RotationSnap = 45.0f

private

Referenced by OnImGuiRender().

m_ScaleSnap

float Muto::EditorLayer::m_ScaleSnap = 0.5f

private

Referenced by OnImGuiRender().

m_SceneHierarchyPanel

SceneHierarchyPanel Muto::EditorLayer::m_SceneHierarchyPanel

private

m_SceneState

SceneState Muto::EditorLayer::m_SceneState = SceneState::Edit

private

Referenced by OnEvent().

m_SmokeEntity

Entity Muto::EditorLayer::m_SmokeEntity

private

m_SpecialQuadColor

glm::vec4 Muto::EditorLayer::m_SpecialQuadColor = { 0.9f, 0.2f, 0.8f, 1.0f }

private

{ 0.9f, 0.2f, 0.8f, 1.0f };

m_specialQuadRotation

float Muto::EditorLayer::m_specialQuadRotation = 0.5f

private

m_SpriteSheetCrystals

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetCrystals

private

m_SpriteSheetCursedLands

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetCursedLands

private

m_SpriteSheetFire

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetFire

private

m_SpriteSheetRocks

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetRocks

private

m_SpriteSheetSmoke

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetSmoke

private

m_SpriteSheetTown

Ref<Texture2D> Muto::EditorLayer::m_SpriteSheetTown

private

m_SquareColor

glm::vec4 Muto::EditorLayer::m_SquareColor = { 0.2f, 0.3f, 0.8f, 1.0f }

private

{ 0.2f, 0.3f, 0.8f, 1.0f };

m_squareRotation

float Muto::EditorLayer::m_squareRotation = 25.0f

private

m_SquareVA

Ref<VertexArray> Muto::EditorLayer::m_SquareVA

private

m_SubTextureFire

Ref<SubTexture2D> Muto::EditorLayer::m_SubTextureFire

private

m_SubTextureSmoke

Ref<SubTexture2D> Muto::EditorLayer::m_SubTextureSmoke

private

m_SubTextureTown

Ref<SubTexture2D> Muto::EditorLayer::m_SubTextureTown

private

m_textureScale

float Muto::EditorLayer::m_textureScale = 1.0f

private

m_TextureTintColor1

glm::vec4 Muto::EditorLayer::m_TextureTintColor1 = { 1.0f, 1.0f, 1.0f, 1.0f }

private

{ 1.0f, 1.0f, 1.0f, 1.0f };

m_TextureTintColor2

glm::vec4 Muto::EditorLayer::m_TextureTintColor2 = { 1.0f, 1.0f, 1.0f, 1.0f }

private

{ 1.0f, 1.0f, 1.0f, 1.0f };

m_TranslationSnap

float Muto::EditorLayer::m_TranslationSnap = 0.5f

private

Referenced by OnImGuiRender().

m_UseSpecialQuadColor

bool Muto::EditorLayer::m_UseSpecialQuadColor = false

private

m_ViewportBounds

glm::vec2 Muto::EditorLayer::m_ViewportBounds[2] = { {0,0}, {0,0} }

private

{ {0,0}, {0,0} };

m_ViewportFocused

bool Muto::EditorLayer::m_ViewportFocused = false

private

Referenced by OnImGuiRender(), and OnUpdate().

m_ViewportHovered

bool Muto::EditorLayer::m_ViewportHovered = false

private

Referenced by OnImGuiRender().

m_ViewportSize

glm::vec2 Muto::EditorLayer::m_ViewportSize = {0,0}

private

{0,0};

s_TextureMap

std::unordered_map<char, Ref<SubTexture2D> > Muto::EditorLayer::s_TextureMap

private

scene1

bool Muto::EditorLayer::scene1 = false

private

scene2

bool Muto::EditorLayer::scene2 = false

private

scene3

bool Muto::EditorLayer::scene3 = false

private

scene4

bool Muto::EditorLayer::scene4 = false

private

useEntityScene

bool Muto::EditorLayer::useEntityScene = true

private

---

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

• Muto/src/Editor/EditorLayer.h
• Muto/src/Editor/EditorLayer.cpp