Vesper::EditorLayer Class Reference

#include <EditorLayer.h>

Inheritance diagram for Vesper::EditorLayer:

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

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

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

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

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

Member Enumeration Documentation

SceneState

enum class Vesper::EditorLayer::SceneState

strongprivate

Enumerator
Edit
Play
Simulate

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

Constructor & Destructor Documentation

EditorLayer()

Vesper::EditorLayer::EditorLayer

(

)

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

References EditorLayer().

Referenced by EditorLayer(), and Vesper::VesperEditor::VesperEditor().

~EditorLayer()

virtual Vesper::EditorLayer::~EditorLayer ( )

virtualdefault

Member Function Documentation

NewScene()

void Vesper::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 Vesper::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

Reimplemented from Vesper::Layer.

    {
        VZ_PROFILE_FUNCTION();
 
        // Texture / SubTexture setup
        {
            m_CheckerboardTexture = Texture2D::Create("../../Vesper-Editor/assets/textures/Checkerboard.png");
            m_SpriteSheetFire = Texture2D::Create("../../Vesper-Editor/assets/textures/sheets/fire_01.png");
            m_SpriteSheetSmoke = Texture2D::Create("../../Vesper-Editor/assets/textures/sheets/fire_02.png");
            m_SpriteSheetTown = Texture2D::Create("../../Vesper-Editor/assets/textures/sheets/town_tilesheet.png");
            m_SpriteSheetCrystals = Texture2D::Create("../../Vesper-Editor/assets/textures/sheets/craftpix/Crystals/Crystals.png");
            m_SpriteSheetRocks = Texture2D::Create("../../Vesper-Editor/assets/textures/sheets/craftpix/Rocks/Rocks_source.png");
            m_SpriteSheetCursedLands = Texture2D::Create("../../Vesper-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 (VZ_EDITOR_USE_DEFAULT_SCENE) {
                std::string loadedScene = FileSystem::GetAbsolutePath("../../" + std::string(VZ_EDITOR_DEFAULT_SCENE));
 
                bool valid = serializer.Deserialize(loadedScene);
                if (!valid) {
                    VZ_CORE_ERROR("Failed to load default scene: " + loadedScene);
                    VZ_CORE_ERROR("Attempted Scene: " + std::string(VZ_EDITOR_DEFAULT_SCENE));
                    VZ_CORE_ERROR("Current Working Directory: " + FileSystem::GetCurrentWorkingDirectory());
                    VZ_CORE_ERROR("Absolute Path Attempted: " + FileSystem::GetAbsolutePath(loadedScene));
                    VZ_CORE_ERROR("Error loading the scene, please check the paths and file availability.");
                }
                else {
                    VZ_CORE_INFO("Successfully loaded the default scene: " + loadedScene);
                }
            }
            m_EditorCamera = EditorCamera(30.0f, 1.778f, 0.1f, 1000.0f);
        }
 
 
    }

References Vesper::SceneSerializer::Deserialize(), Vesper::FramebufferSpecification::Height, Vesper::FileSystem::Initialize(), and Vesper::FramebufferSpecification::Width.

OnDetach()

void Vesper::EditorLayer::OnDetach ( )

overridevirtual

Called when the layer is detached from the application.

Reimplemented from Vesper::Layer.

    {
        VZ_PROFILE_FUNCTION();
    }

OnEvent()

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

overridevirtual

Called when an event is dispatched to the layer.

Parameters

event

The event being dispatched.

Reimplemented from Vesper::Layer.

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

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

OnImGuiRender()

void Vesper::EditorLayer::OnImGuiRender ( )

overridevirtual

Called when the layer should render its ImGui components.

Reimplemented from Vesper::Layer.

    {
        VZ_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"))
                    Vesper::Application::Get().Close();
 
                ImGui::EndMenu();
            }
 
            ImGui::EndMenuBar();
        }
 
        {
            if (ImGui::Begin("Scenes"))
            {
                if (ImGui::Checkbox("Entity Scene", &useEntityScene)) {
                    if (useEntityScene) {
                        scene1 = false;
                        scene2 = false;
                        scene3 = false;
                        scene4 = false;
                    }
                }
                if (ImGui::Checkbox("Scene 1 - Basic Shapes", &scene1)) {
                    if (scene1) {
                        scene2 = false;
                        scene3 = false;
                        scene4 = false;
                    }
                }
                if (ImGui::Checkbox("Scene 2 - Sprite Sheets", &scene2)) {
                    if (scene2) {
                        scene1 = false;
                        scene3 = false;
                        scene4 = false;
                    }
                }
                if (ImGui::Checkbox("Scene 3 - Tile Map", &scene3)) {
                    if (scene3) {
                        scene1 = false;
                        scene2 = false;
                        scene4 = false;
                    }
                }
                if (ImGui::Checkbox("Scene 4 - Particle System", &scene4)) {
                    if (scene4) {
                        scene1 = false;
                        scene2 = false;
                        scene3 = false;
                    }
                }
            }
            ImGui::End();
        }
 
        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();
        }
 
        DisplayVesperInfo_ImGui();
 
        {
            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;
                    Vesper::Math::DecomposeTransform(transform, translation, rotation, scale);
                    tc.Translation = translation;
                    tc.Rotation = rotation;
                    tc.Scale = scale;
                }
            }
 
            ImGui::End();
            ImGui::PopStyleVar();
        }
        ImGui::End();
    }

References Vesper::Application::Close(), Vesper::DisplayVesperInfo_ImGui(), Vesper::Application::Get(), Vesper::Application::GetImGuiLayer(), Vesper::Renderer2D::GetStats(), Vesper::Input::IsKeyPressed(), Vesper::Key::LeftControl, m_GizmoType, m_RotationSnap, m_ScaleSnap, m_TranslationSnap, m_ViewportFocused, m_ViewportHovered, NewScene(), OpenScene(), ResetScene(), SaveSceneAs(), scene1, scene2, scene3, scene4, Vesper::ImGuiLayer::SetBlockEvents(), and useEntityScene.

OnKeyPressed()

bool Vesper::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 Vesper::KeyEvent::GetKeyCode(), Vesper::KeyPressedEvent::GetRepeatCount(), Vesper::Input::IsKeyPressed(), Vesper::Key::LeftControl, Vesper::Key::LeftShift, m_GizmoType, Vesper::Key::N, NewScene(), Vesper::Key::O, OpenScene(), Vesper::Key::Q, Vesper::Key::RightControl, Vesper::Key::RightShift, Vesper::Key::S, and SaveSceneAs().

Referenced by OnEvent().

OnUpdate()

void Vesper::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.

C++ test code scenes

TODO: get it to animate through texture sheet sub texture indices

Reimplemented from Vesper::Layer.

    {
        VZ_PROFILE_FUNCTION();
 
        // Resize
        if (Vesper::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();
        {
            VZ_PROFILE_SCOPE("Renderer Prep");
            m_Framebuffer->Bind();
            RenderCommand::SetClearColor(m_ClearColor);
            RenderCommand::Clear();
        }
 
 
        // Draw
        {
            static float rotation = 0.0f;
            rotation += ts * 50.0f;
            VZ_PROFILE_SCOPE("Renderer2D Draw");

            {
                // Basic scene
                if (scene1)
                {
                    VZ_PROFILE_SCOPE("Scene 1");
                    Renderer2D::BeginScene(m_CameraController.GetCamera());
 
                    // Checkerboard background
                    Renderer2D::DrawQuadWithTexture({ 0.0f, 0.0f, -0.25f }, { 25.0f, 25.0f }, m_CheckerboardTexture, 10.0f, m_BackgroundColor);
 
                    // Squares
                    Renderer2D::DrawQuadRotated({ 0.0f, 1.25f, -0.165f }, { 1.0f, 1.0f }, glm::radians(45.0f + m_squareRotation + rotation), m_SquareColor);
 
                    // Rotated Squares
                    Renderer2D::DrawQuadRotatedWithTexture({ 0.0f, 1.25f, -0.15f }, { 0.75f, 0.75f }, m_CheckerboardTexture, glm::radians(m_squareRotation * m_specialQuadRotation * rotation), m_textureScale, m_SpecialQuadColor);
 
                    Renderer2D::DrawQuadRotatedWithTexture({ 2.0f, -0.25f, -0.15f }, { 1.0f, 1.0f }, m_CheckerboardTexture, glm::radians(m_squareRotation + rotation), m_textureScale, m_TextureTintColor1);
                    Renderer2D::DrawQuadRotatedWithTexture({ -2.0f, -0.25f, -0.15f }, { 1.0f, 1.0f }, m_CheckerboardTexture, glm::radians(m_squareRotation + rotation), m_textureScale, m_TextureTintColor2);
 
                    glm::vec3 startPos = { 0.0f, 0.0f, -0.175f };
                    //Renderer2D::DrawQuad(pos, { 0.8f, 0.8f }, { 0.8f, 0.2f, 0.3f, 1.0f });
                    glm::vec3 finalPos = startPos;
                    float offset = 0.9f;
                    for (int y = -10; y <= 10; y++)
                    {
                        for (int x = -10; x <= 10; x++)
                        {
                            glm::vec3 newPos = { startPos.x - x * offset, startPos.y - y * offset, startPos.z };
                            Renderer2D::DrawQuad(newPos, { 0.8f, 0.8f }, { (x + 5) / 10.0f, 0.4f, (y + 5) / 10.0f, 1.0f });
                            finalPos = newPos;
                        }
                    }
                    Renderer2D::DrawQuad(finalPos, { 0.8f, 0.8f }, { 0.8f, 0.2f, 0.3f, 1.0f });
 
                    Renderer2D::EndScene();
 
                }
 
                // Sprite sheet scene
                if (scene2)
                {
                    VZ_PROFILE_SCOPE("Scene 2");
 
                    Renderer2D::BeginScene(m_CameraController.GetCamera());
 
                    // Sprite sheet drawn as full texture
                    Renderer2D::DrawQuadWithTexture({ -1.0f, 1.5f, 0.5f }, { 1, 1 }, m_SpriteSheetFire, 1.0f, { 1.0f, 1.0f, 1.0f, 1.0f });
                    Renderer2D::DrawQuadRotatedWithTexture({ 1.5f, 0.0f, 0.0f }, { 1.78f, 1.0f }, m_SpriteSheetTown, 0, 1.0f, { 1.0f, 1.0f, 1.0f, 1.0f });
 
 
                    // Sprite sheet drawn as full texture rotated
                    Renderer2D::DrawQuadRotatedWithTexture({ -1.5f, 0.0f, 0.0f }, { 1.78f, 1.0f }, m_SpriteSheetTown, glm::radians(-rotation), 1.0f, { 1.0f, 1.0f, 1.0f, 1.0f });
 
                    // Sub texture from tilesheet
                    Renderer2D::DrawQuadWithTexture({ 2.0f, -1.5f, 0.0f }, { 1.0f, 1.0f }, m_SubTextureTown, 1.0f, { 1.0f, 1.0f, 1.0f, 1.0f });
 
                    // Grid of sub textures from tilesheet
                    for (int y = -5; y < 5; y++)
                    {
                        for (int x = -5; x < 5; x++)
                        {
                            glm::vec3 pos = glm::vec3(x * 0.09f, y * 0.09f, -0.09f);
                            Renderer2D::DrawQuadWithTexture(pos, { 0.1f, 0.1f }, m_SubTextureTown, 1.0f, glm::vec4(1.0f));
                        }
                    }

                    Renderer2D::DrawQuadRotatedWithTexture({ 0.0f, -1.5f, 0.0f }, { 1.0f, 1.0f }, m_SubTextureFire, 0, 1.0f, { 1.0f, 1.0f, 1.0f, 1.0f });
 
                    Renderer2D::EndScene();
                }
 
                // Tile map scene
                if (scene3)
                {
                    VZ_PROFILE_SCOPE("Scene 3");
                    Renderer2D::BeginScene(m_CameraController.GetCamera());
                    for (uint32_t y = 0; y < s_MapHeight; y++)
                    {
                        for (uint32_t x = 0; x < s_MapWidth; x++)
                        {
                            char tileChar = s_MapTiles[x + y * s_MapWidth];
                            Ref<SubTexture2D> texture;
                            if (s_TextureMap.find(tileChar) != s_TextureMap.end())
                                texture = s_TextureMap[tileChar];
                            else
                                texture = s_TextureMap['G']; // Default to grass
 
                            Renderer2D::DrawQuadWithTexture({ x - s_MapWidth / 2.0f, s_MapHeight - y - s_MapHeight / 2.0f, 0.1f }, { 1.0f, 1.0f }, texture, 1.0f, glm::vec4(1.0f));
 
                        }
                    }
                    Renderer2D::EndScene();
                }
 
                // Particle scene
                if (scene4)
                {
                    VZ_PROFILE_SCOPE("Scene 4");
                    Renderer2D::BeginScene(m_CameraController.GetCamera());
                    for (float y = -5.0f; y < 5.0f; y += 0.5f)
                    {
                        for (float x = -5.0f; x < 5.0f; x += 0.5f)
                        {
                            glm::vec4 color = { (x + 5.0f) / 10.0f, 0.4f,(y + 5.0f) / 10.0f, 0.35f };
                            Renderer2D::DrawQuad({ x, y }, { 0.45f, 0.45f }, color);
                        }
                    }
 
                    if (Input::IsMouseButtonPressed(Mouse::ButtonLeft) && m_ViewportHovered)
                    {
                        ImVec2 mousePos = ImGui::GetMousePos();
 
                        mousePos.x -= m_ViewportBounds[0].x;
                        mousePos.y -= m_ViewportBounds[0].y;
 
                        if (mousePos.x < 0 || mousePos.y < 0 || mousePos.x > m_ViewportSize.x || mousePos.y > m_ViewportSize.y)
                            return;
 
                        auto bounds = m_CameraController.GetBounds();
                        auto camPos = m_CameraController.GetPosition();
 
                        float width = m_ViewportSize.x;
                        float height = m_ViewportSize.y;
 
                        m_ParticleProps.Position.x = (mousePos.x / width) * bounds.GetWidth() - bounds.GetWidth() * 0.5f + camPos.x;
                        m_ParticleProps.Position.y = bounds.GetHeight() * 0.5f - (mousePos.y / height) * bounds.GetHeight() + camPos.y;
 
                        for (int i = 0; i < ParticleEmitCount; i++) {
                            m_ParticleSystem.Emit(m_ParticleProps);
                        }
                    }
                    m_ParticleSystem.OnUpdate(ts);
                    m_ParticleSystem.OnRender(m_CameraController.GetCamera());
                    Renderer2D::EndScene();
 
                }
            }
 
            if (useEntityScene)
            {
                VZ_PROFILE_SCOPE("Entity Scene Update");
                // Update scene
                    m_ActiveScene->OnUpdateRuntime(ts);
                    m_ActiveScene->OnUpdateEditor(ts, m_EditorCamera);
            }
        }
 
        m_Framebuffer->Unbind();
    }

References Vesper::Mouse::ButtonLeft, Vesper::RenderCommand::Clear(), Vesper::Renderer2D::EndScene(), Vesper::Input::IsMouseButtonPressed(), m_ViewportFocused, m_ViewportHovered, ParticleEmitCount, Vesper::Renderer2D::ResetStats(), s_MapHeight, s_MapTiles, s_MapWidth, scene1, scene2, scene3, scene4, and useEntityScene.

OpenScene()

void Vesper::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);
            VZ_CORE_INFO("Scene deserialized from: " + filePath);
        }
    }

References Vesper::SceneSerializer::Deserialize().

Referenced by OnImGuiRender(), and OnKeyPressed().

ResetScene()

void Vesper::EditorLayer::ResetScene ( )

private

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

Referenced by OnImGuiRender().

SaveSceneAs()

void Vesper::EditorLayer::SaveSceneAs ( )

private

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

References Vesper::SceneSerializer::Serialize().

Referenced by OnImGuiRender(), and OnKeyPressed().

Member Data Documentation

lastFrameTime

float Vesper::EditorLayer::lastFrameTime = 0.0f

private

m_ActiveScene

Ref<Scene> Vesper::EditorLayer::m_ActiveScene

private

m_BackgroundColor

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

private

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

m_CameraController

OrthographicCameraController Vesper::EditorLayer::m_CameraController

private

m_CameraEntity

Entity Vesper::EditorLayer::m_CameraEntity

private

m_CheckerboardTexture

Ref<Texture2D> Vesper::EditorLayer::m_CheckerboardTexture

private

m_ClearColor

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

private

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

m_EditorCamera

EditorCamera Vesper::EditorLayer::m_EditorCamera

private

m_EditorScene

Ref<Scene> Vesper::EditorLayer::m_EditorScene

private

m_FireEntity

Entity Vesper::EditorLayer::m_FireEntity

private

m_FlatColorShader

Ref<Shader> Vesper::EditorLayer::m_FlatColorShader

private

m_Framebuffer

Ref<Framebuffer> Vesper::EditorLayer::m_Framebuffer

private

m_GizmoType

int Vesper::EditorLayer::m_GizmoType = -1

private

Referenced by OnImGuiRender(), and OnKeyPressed().

m_ParticleProps

ParticleProps Vesper::EditorLayer::m_ParticleProps

private

m_ParticleSystem

ParticleSystem Vesper::EditorLayer::m_ParticleSystem

private

m_PrimaryCamera

bool Vesper::EditorLayer::m_PrimaryCamera = true

private

m_RotationSnap

float Vesper::EditorLayer::m_RotationSnap = 45.0f

private

Referenced by OnImGuiRender().

m_ScaleSnap

float Vesper::EditorLayer::m_ScaleSnap = 0.5f

private

Referenced by OnImGuiRender().

m_SceneHierarchyPanel

SceneHierarchyPanel Vesper::EditorLayer::m_SceneHierarchyPanel

private

m_SceneState

SceneState Vesper::EditorLayer::m_SceneState = SceneState::Edit

private

Referenced by OnEvent().

m_SmokeEntity

Entity Vesper::EditorLayer::m_SmokeEntity

private

m_SpecialQuadColor

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

private

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

m_specialQuadRotation

float Vesper::EditorLayer::m_specialQuadRotation = 0.5f

private

m_SpriteSheetCrystals

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetCrystals

private

m_SpriteSheetCursedLands

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetCursedLands

private

m_SpriteSheetFire

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetFire

private

m_SpriteSheetRocks

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetRocks

private

m_SpriteSheetSmoke

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetSmoke

private

m_SpriteSheetTown

Ref<Texture2D> Vesper::EditorLayer::m_SpriteSheetTown

private

m_SquareColor

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

private

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

m_squareRotation

float Vesper::EditorLayer::m_squareRotation = 25.0f

private

m_SquareVA

Ref<VertexArray> Vesper::EditorLayer::m_SquareVA

private

m_SubTextureFire

Ref<SubTexture2D> Vesper::EditorLayer::m_SubTextureFire

private

m_SubTextureSmoke

Ref<SubTexture2D> Vesper::EditorLayer::m_SubTextureSmoke

private

m_SubTextureTown

Ref<SubTexture2D> Vesper::EditorLayer::m_SubTextureTown

private

m_textureScale

float Vesper::EditorLayer::m_textureScale = 1.0f

private

m_TextureTintColor1

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

private

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

m_TextureTintColor2

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

private

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

m_TranslationSnap

float Vesper::EditorLayer::m_TranslationSnap = 0.5f

private

Referenced by OnImGuiRender().

m_UseSpecialQuadColor

bool Vesper::EditorLayer::m_UseSpecialQuadColor = false

private

m_ViewportBounds

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

private

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

m_ViewportFocused

bool Vesper::EditorLayer::m_ViewportFocused = false

private

Referenced by OnImGuiRender(), and OnUpdate().

m_ViewportHovered

bool Vesper::EditorLayer::m_ViewportHovered = false

private

Referenced by OnImGuiRender(), and OnUpdate().

m_ViewportSize

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

private

{0,0};

ParticleEmitCount

int Vesper::EditorLayer::ParticleEmitCount = 100

private

Referenced by OnUpdate().

s_TextureMap

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

private

scene1

bool Vesper::EditorLayer::scene1 = false

private

Referenced by OnImGuiRender(), and OnUpdate().

scene2

bool Vesper::EditorLayer::scene2 = false

private

Referenced by OnImGuiRender(), and OnUpdate().

scene3

bool Vesper::EditorLayer::scene3 = false

private

Referenced by OnImGuiRender(), and OnUpdate().

scene4

bool Vesper::EditorLayer::scene4 = false

private

Referenced by OnImGuiRender(), and OnUpdate().

useEntityScene

bool Vesper::EditorLayer::useEntityScene = true

private

Referenced by OnImGuiRender(), and OnUpdate().

---

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

• Vesper-Editor/src/EditorLayer.h
• Vesper-Editor/src/EditorLayer.cpp