YoggieEngine/Editor/src/EditorLayer.h

#pragma once
#include <iostream>
#include <mini/ini.h>
#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "AssetManagement/SceneSerializer.h"
#include "AssetManagement/AssetRegistry.h"
#include "Views/Viewport.h"
#include "PropertyPanels/SceneExplorer.h"
#include "AssetManagement/AssetFinder.h"
#include "MainMenuBar.h"
#include "PropertyPanels/Inspector.h"
#include "Project/ProjectInfo.h"
#include "Runtime/RuntimeControls.h"
#include "AssetManagement/uuid.h"
#include "Project/Settings.h"
#include "Console.h"
#include "AssetManagement/AssetLoaders/ModelLoader.h"

using namespace YoggieEngine;
class EditorLayer : public Layer {

public:
	EditorLayer():
        Layer(),
        rc(),
        sceneview(scene, Selected),
        explorer(Selected, scene),
        inspector (Selected)
    {
    }

	void OnStartup() override {
        std::string path = (std::filesystem::current_path()).string();
        project.setProjectDirectory(path);
        assetsView = AssetFinder(project.GetProjectDirectory());
        LoadLastOrEmptyProject();

        AssetRegistry assetManager = AssetRegistry();
        ModelLoader modelLoader = ModelLoader();

        spdlog::info( "{0}", project.GetProjectDirectory().string());

        auto latern = modelLoader.LoadAsset(std::filesystem::path("build/debug/Models/Latern.gltf"));
        spdlog::info( "Loaded mesh: {0}" , latern.GetName() );

        //ProjectInfo projectInfo(project);
        //Settings settings = Settings();
        //Console console = Console();
 


        Selected = YoggieEngine::Entity((entt::entity)-1, &scene);

	}

	void OnUpdate() override {
        scene.Update();

		if (sceneview.isFocused) {
			UpdateSceneCamera(sceneview);

			spdlog::info( "Scene view in Focus!\r");
		}

	}


    void OnUI() override {
        {
            MainMenuBar menuBar = MainMenuBar();
            menuBar.ApplicationMenu(project);
            menuBar.SceneMenu(project, scene);
            menuBar.SelectMenu();
            menuBar.WindowMenu();
            menuBar.DebugMenu();
            menuBar.Help();

        }

        //projectInfo.Update();
        sceneview.Update();
        rc.Update();
        explorer.Update();
        //settings.Update();
        inspector.Update();
        //console.Update();

        assetsView.Update();

        ImGui::ShowDemoWindow();
        //ImGui::ShowMetricsWindow();
    }

	
	void OnCreate() override {
		spdlog::info(" Layer Create!" );

	}

	void OnDestroy() override {
		spdlog::info( " Layer Destroy!" );

	}


private:

    RuntimeControls rc;
    Viewport sceneview ;
    SceneExplorer explorer;
    Inspector inspector;
    AssetFinder assetsView;

    bool SimulatePhysics = true;
    YoggieEngine::Entity  Selected;
    Project project;
    Scene scene;

    void LoadLastOrEmptyProject() {
        // Check if there is a last known loaded project and 
       // load that one .

       // Otherwise load no project..
       // OR 
       // Load an empty project.
        mINI::INIStructure ini;

        if (std::filesystem::exists("build\\Debug\\Editor.ini"))
        {
            mINI::INIFile file("build\\Debug\\Editor.ini");
            file.read(ini);
        }
        else
        {
            spdlog::debug("Could not find an `Editor.ini` file.");
        }

        if (ini["editor"]["openlastproject"] == "TRUE")
        {

            Project::LoadProject(ini["cache"]["project"], project);
            LoadScene(ini["cache"]["scene"], scene);

        }
        else
        {
            spdlog::debug("Starting without a project. Please create one.");
        }
    }


    void UpdateSceneCamera(Viewport& sceneview) {
        const float movement_speed = 0.01f;
        static float lastX = 400, lastY = 300;
        const float sensitivity = 0.1;
        static bool firstMouse = true;

        /*

        if (MouseButtonPressed(YOGGIE_MOUSE_BUTTON_RIGHT)) {

            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
            auto newX = getCursorPosX(appWindow);
            auto newY = getCursorPosY(appWindow);

            if (firstMouse)
            {
                lastX = newX;
                lastY = newY;
                firstMouse = false;
            }


            float xoffset = newX - lastX;
            float yoffset = newY - lastY;

            lastX = newX;
            lastY = newY;

            xoffset *= sensitivity;
            yoffset *= sensitivity;

            sceneview.cam.Rotation.x += (xoffset / 2);
            sceneview.cam.Rotation.y += (xoffset /2);
            sceneview.cam.Rotation.z += yoffset;


            if (sceneview.cam.pitch > 89.0f)
                sceneview.cam.pitch = 89.0f;
            if (sceneview.cam.pitch < -89.0f)
                sceneview.cam.pitch = -89.0f;


        }
        else if (firstMouse == false)
        {
            glfwSetInputMode((GLFWwindow*)appWindow->GetHandle(), GLFW_CURSOR, GLFW_CURSOR_NORMAL);
            firstMouse = true;
        }



        */
        
        EditorCamera& cam = sceneview.GetCamera();

        
        
        if (keyIsPressed(YOGGIE_KEY_UP))
            cam.Rotation.x += movement_speed;

        if (keyIsPressed(YOGGIE_KEY_DOWN))
            cam.Rotation.x -= movement_speed;

        if (keyIsPressed(YOGGIE_KEY_LEFT))
            cam.Rotation.y += movement_speed;

        if (keyIsPressed(YOGGIE_KEY_RIGHT))
            cam.Rotation.y -= movement_speed;


        cam.Update();



        /*

        // Check for Camara movement input here!
        if (keyIsPressed(YOGGIE_KEY_W))
            sceneview.cam.Position -= sceneview.cam.Front * movement_speed;

        if (keyIsPressed(YOGGIE_KEY_A))
            sceneview.cam.Position += sceneview.cam.Right * movement_speed;

        if (keyIsPressed(YOGGIE_KEY_S))
            sceneview.cam.Position += sceneview.cam.Front * movement_speed;

        if (keyIsPressed(YOGGIE_KEY_D))
            sceneview.cam.Position -= sceneview.cam.Right * movement_speed;
            */


    }

};