Editor.h

Go to the documentation of this file.

#pragma once
 
#include "EditorCore/TClassEventDispatcher.h"
#include "EditorCore/Event/KeyPressedEvent.h"
#include "EditorCore/Event/KeyReleasedEvent.h"
#include "EditorCore/Event/DisplayFramebufferResizedEvent.h"
#include "EditorCore/Event/SceneFramebufferResizedEvent.h"
#include "EditorCore/Event/DisplayClosedEvent.h"
#include "EditorCore/Event/DisplayFocusChangedEvent.h"
#include "EditorCore/Event/AppModuleActionEvent.h"
#include "App/Event/DesignerSceneAddedEvent.h"
#include "App/Event/DesignerSceneRemovalEvent.h"
#include "App/Event/ActiveDesignerSceneChangedEvent.h"
#include "App/EditorEventQueue.h"
#include "App/HelpMenu/HelpMenu.h"
#include "App/Misc/DimensionHints.h"
#include "App/Misc/EditorStats.h"
#include "EditorCore/FileSystemExplorer.h"
#include "App/EditContext.h"
#include "App/Event/EditContextUpdatedEvent.h"
 
#include <Common/assertion.h>
#include <Common/primitive_type.h>
#include <Utility/TFunction.h>
#include <Utility/TUniquePtrVector.h>
#include <Utility/INoCopyAndMove.h>
 
#include <cstddef>
#include <list>
#include <string>
#include <memory>
 
namespace ph { class Path; }
 
namespace ph::editor
{
 
class DesignerScene;
class MainThreadUpdateContext;
class MainThreadRenderUpdateContext;
class RenderThreadCaller;
class EditorSettings;
 
class Editor final : private INoCopyAndMove
{
public:
    HelpMenu helpMenu;
    DimensionHints dimensionHints;
    EditorStats editorStats;
    FileSystemExplorer fileExplorer;
 
    Editor();
    ~Editor();
 
    void start();
 
    void update(const MainThreadUpdateContext& ctx);
    void renderUpdate(const MainThreadRenderUpdateContext& ctx);
    void createRenderCommands(RenderThreadCaller& caller);
    void beforeUpdateStage();
    void afterUpdateStage();
    void beforeRenderStage();
    void afterRenderStage();
 
    void stop();
 
    void renderCleanup(RenderThreadCaller& caller);
    void cleanup();
 
    std::size_t createScene(const Path& workingDirectory, const std::string& name = "");
 
    std::size_t createSceneFromDescription(
        const Path& workingDirectory,
        const Path& sceneDescription,
        const std::string& name = "",
        const std::string& descName = "");
 
    std::size_t loadScene(const Path& sceneFile);
 
    void saveScene();
 
    void saveScene(std::size_t sceneIndex);
 
    DesignerScene* getScene(std::size_t sceneIndex) const;
    DesignerScene* getActiveScene() const;
    void setActiveScene(std::size_t sceneIndex);
    void removeScene(std::size_t sceneIndex);
    std::size_t numScenes() const;
 
    std::size_t getSceneIndex(const DesignerScene* scene) const;
 
    EditContext getEditContext() const;
 
    static constexpr std::size_t nullSceneIndex();
 
private:
    struct PendingRemovalScene
    {
        std::unique_ptr<DesignerScene> scene;
        bool hasRenderCleanupDone = false;
        bool hasCleanupDone = false;
    };
 
    TUniquePtrVector<DesignerScene> m_scenes;
    std::list<PendingRemovalScene> m_removingScenes;
    DesignerScene* m_activeScene = nullptr;
    bool m_isActiveScenePaused = false;
 
    std::size_t newScene();
 
    void loadDefaultScene();
    void cleanupRemovingScenes();
    void renderCleanupRemovingScenes(RenderThreadCaller& caller);
 
// Event System
public:
    template<typename EventType>
    using TEditorEventDispatcher = TClassEventDispatcher<EventType, Editor>;
 
    TEditorEventDispatcher<KeyPressedEvent> onKeyPressed;
    TEditorEventDispatcher<KeyReleasedEvent> onKeyReleased;
    TEditorEventDispatcher<DisplayFramebufferResizedEvent> onDisplayFramebufferResized;
    TEditorEventDispatcher<SceneFramebufferResizedEvent> onSceneFramebufferResized;
    TEditorEventDispatcher<DisplayClosedEvent> onDisplayClosed;
    TEditorEventDispatcher<DisplayFocusChangedEvent> onDisplayFocusChanged;
    TEditorEventDispatcher<AppModuleActionEvent> onAppModuleAction;
    TEditorEventDispatcher<EditContextUpdatedEvent> onEditContextUpdated;
    TEditorEventDispatcher<DesignerSceneAddedEvent> onDesignerSceneAdded;
    TEditorEventDispatcher<DesignerSceneRemovalEvent> onDesignerSceneRemoval;
    TEditorEventDispatcher<ActiveDesignerSceneChangedEvent> onActiveDesignerSceneChanged;
 
    template<typename EventType>
    void postEvent(const EventType& e, TEditorEventDispatcher<EventType>& eventDispatcher);
 
private:
    template<typename EventType>
    static void dispatchPostedEventToListeners(
        const EventType& e, 
        TEditorEventDispatcher<EventType>& eventDispatcher);
 
    void flushAllEvents();
 
    EditorEventQueue m_eventPostQueue;
 
    // TODO: may require obj/entity add/remove event queue to support concurrent event 
    // (to avoid invalidating Listener on addListener())
// End Event System
 
public:
    void loadSettings(const Path& settingsFile);
    void saveSettings(const Path& settingsFile) const;
    EditorSettings& getSettings() const;
 
private:
    std::shared_ptr<EditorSettings> m_settings;
};
 
}// end namespace ph::editor
 
#include "App/Editor.ipp"