DesignerScene.h

Go to the documentation of this file.

#pragma once
 
#include "Designer/designer_fwd.h"
#include "Designer/ViewportCamera.h"
#include "EditorCore/TClassEventDispatcher.h"
#include "Designer/Event/DesignerObjectAddedEvent.h"
#include "Designer/Event/DesignerObjectRemovalEvent.h"
 
#include <Common/primitive_type.h>
#include <Common/logging.h>
#include <Utility/TUniquePtrVector.h>
#include <Utility/TSpan.h>
#include <SDL/Object.h>
#include <SDL/sdl_interface.h>
#include <SDL/SceneDescription.h>
#include <Utility/IMoveOnly.h>
#include <DataIO/FileSystem/Path.h>
#include <DataIO/FileSystem/ResourceIdentifier.h>
#include <Utility/TFunction.h>
 
#include <vector>
#include <memory>
#include <cstddef>
#include <string>
#include <string_view>
#include <functional>
#include <unordered_map>
#include <array>
 
namespace ph { class SdlClass; }
namespace ph::editor::render { class System; }
namespace ph::editor::render { class Scene; }
namespace ph::editor::render { class RealtimeRenderer; }
namespace ph::editor::render { class OfflineRenderer; }
 
namespace ph::editor
{
 
class Editor;
class MainThreadUpdateContext;
class MainThreadRenderUpdateContext;
class RenderThreadCaller;
class RenderAgent;
 
PH_DECLARE_LOG_GROUP(DesignerScene);
 
class DesignerRendererBinding final
{
public:
    RenderAgent* agent = nullptr;
    render::RealtimeRenderer* realtimeRenderer = nullptr;
    render::OfflineRenderer* offlineRenderer = nullptr;
};
 
class DesignerScene final 
    : public Object
    , private IMoveOnly
{
public:
    // Work type should be kept in sync with `RenderThread::Work`
    using RenderWorkType = TFunction<void(render::System&)>;
 
    static const char* defaultSceneName();
 
public:
    explicit DesignerScene(Editor* fromEditor);
    DesignerScene(DesignerScene&& other) noexcept;
    ~DesignerScene() override;
 
    void update(const MainThreadUpdateContext& ctx);
    void renderUpdate(const MainThreadRenderUpdateContext& ctx);
    void createRenderCommands(RenderThreadCaller& caller);
    void beforeUpdateStage();
    void afterUpdateStage();
    void beforeRenderStage();
    void afterRenderStage();
 
    bool selectObject(DesignerObject* obj);
 
    bool deselectObject(DesignerObject* obj);
 
    DesignerObject* getPrimarySelectedObject() const;
    TSpanView<DesignerObject*> getSelection() const;
    void clearSelection();
 
    void changeObjectVisibility(DesignerObject* obj, bool shouldBeVisible);
    void changeObjectTick(DesignerObject* obj, bool shouldTick);
    void changeObjectRenderTick(DesignerObject* obj, bool shouldTick);
 
 
    template<typename ObjectType>
    [[nodiscard]]
    ObjectType* newObject(
        bool shouldInit = true, 
        bool shouldSetToDefault = true);
 
    template<typename ObjectType>
    ObjectType* newRootObject(
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    template<typename ObjectType>
    std::shared_ptr<ObjectType> newSharedRootObject(
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
 
    [[nodiscard]]
    DesignerObject* newObject(
        const SdlClass* clazz,
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    DesignerObject* newRootObject(
        const SdlClass* clazz,
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    std::shared_ptr<DesignerObject> newSharedRootObject(
        const SdlClass* clazz,
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    void initObject(DesignerObject* obj);
 
    void setObjectToDefault(DesignerObject* obj);
 
    void deleteObject(
        DesignerObject* obj,
        bool shouldDeleteRecursively = true);
 
    void renderCleanup(RenderThreadCaller& caller);
    void cleanup();
 
    Editor& getEditor();
    const Editor& getEditor() const;
    render::Scene& getRendererScene();
    const render::Scene& getRendererScene() const;
    void addRendererBinding(DesignerRendererBinding binding);
    void removeRendererBinding(RenderAgent* agent);
    TSpanView<DesignerRendererBinding> getRendererBindings() const;
 
    const std::string& getName() const;
 
    SceneDescription& getRenderDescription();
 
    const SceneDescription& getRenderDescription() const;
 
    const ResourceIdentifier& getRenderDescriptionLink() const;
 
    void setRenderDescriptionLink(ResourceIdentifier link);
    TSpanView<DesignerObject*> getRootObjects() const;
    std::string getUniqueObjectName(const std::string& intendedName);
 
    void pause();
 
    void resume();
 
    bool isPaused() const;
 
    template<typename ObjectType = DesignerObject>
    ObjectType* findObjectByName(std::string_view name) const;
 
    template<typename ObjectType>
    void findObjectsByType(std::vector<ObjectType*>& out_objs) const;
 
    template<typename PerObjectOperation>
    void forEachUsableObject(PerObjectOperation op) const;
 
    void enqueueObjectRenderWork(DesignerObject* obj, RenderWorkType work);
 
    const Path& getWorkingDirectory() const;
    void setWorkingDirectory(Path directory);
    void setName(std::string name);
 
    std::size_t numRootObjects() const;
    std::size_t numTickingObjects() const;
    std::size_t numRenderTickingObjects() const;
    std::size_t numAllocatedObjects() const;
 
    DesignerScene& operator = (DesignerScene&& rhs) noexcept;
 
    static bool isFullyInitialized(const DesignerObject& obj);
 
    static bool isInitialized(const DesignerObject& obj);
 
// Begin Scene Events
public:
    template<typename EventType>
    using TSceneEventDispatcher = TClassEventDispatcher<EventType, DesignerScene>;
 
    TSceneEventDispatcher<DesignerObjectAddedEvent> onObjectAdded;
    TSceneEventDispatcher<DesignerObjectRemovalEvent> onObjectRemoval;
// End Scene Events
 
private:
    struct SceneAction
    {
        using UpdateTask = TFunction<bool(const MainThreadUpdateContext& ctx), 32>;
        using RenderTask = TFunction<bool(RenderThreadCaller& caller), 32>;
 
        UpdateTask updateTask;
        RenderTask renderTask;
 
        bool isDone() const;
    };
 
    struct RenderWork
    {
        RenderWorkType work;
        DesignerObject* obj = nullptr;
    };
 
    void enqueueCreateObjectAction(DesignerObject* obj);
    void enqueueRemoveObjectAction(DesignerObject* obj);
    void enqueueObjectTickAction(DesignerObject* obj, bool shouldTick);
    void enqueueObjectRenderTickAction(DesignerObject* obj, bool shouldTick);
    void enqueueSceneAction(SceneAction action);
 
    template<typename ObjectType, typename... DeducedArgs>
    ObjectType* makeObjectFromStorage(DeducedArgs&&... args);
 
    bool removeObjectFromStorage(DesignerObject* obj);
 
    void ensureOwnedByThisScene(const DesignerObject* obj) const;
 
    // TODO: rethink more specific use case other than for retargeting object parent
    static bool isOrphan(const DesignerObject& obj);
 
private:
    // Working directory is only set when it can be determined (e.g., during loading).
    // Not saved as working directory can be different on each load.
    Path m_workingDirectory;
 
    TUniquePtrVector<DesignerObject> m_objStorage;
    std::vector<uint64> m_freeObjStorageIndices;
    std::vector<DesignerObject*> m_rootObjs;
    std::vector<DesignerObject*> m_tickingObjs;
    std::vector<DesignerObject*> m_renderTickingObjs;
    std::vector<DesignerObject*> m_selectedObjs;
    std::vector<SceneAction> m_sceneActionQueue;
    std::vector<RenderWork> m_renderWorkQueue;
    std::size_t m_numSceneActionsToProcess;
 
    Editor* m_editor;
    render::Scene* m_rendererScene;
    std::vector<DesignerRendererBinding> m_rendererBindings;
    SceneDescription m_renderDescription;
    ViewportCamera m_mainCamera;
    uint32 m_isPaused : 1;
 
    // SDL-binded fields:
    std::string m_name;
    ResourceIdentifier m_renderDescriptionLink;
 
private:
    using DynamicObjectMaker = std::function<DesignerObject*(DesignerScene& scene)>;
    static std::unordered_map<const SdlClass*, DynamicObjectMaker> classToObjMaker;
 
public:
    template<typename ObjectType>
    static void registerObjectType();
 
    static std::vector<const SdlClass*> getAllObjectClasses();
 
public:
    PH_DEFINE_SDL_CLASS(TSdlOwnerClass<DesignerScene>)
    {
        ClassType clazz("dscene");
        clazz.docName("Designer Scene");
        clazz.description("Designer scene. The main container of designer objects.");
 
        // Creation and removal should be handled by editor
        clazz.allowCreateFromClass(false);
 
        clazz.baseOn<Object>();
 
        TSdlString<OwnerType> name("name", &OwnerType::m_name);
        name.description("Name of the designer scene.");
        name.defaultTo(defaultSceneName());
        clazz.addField(name);
 
        TSdlResourceIdentifier<OwnerType> renderDescriptionLink("render-description-link", &OwnerType::m_renderDescriptionLink);
        renderDescriptionLink.description("Storage location of the associated scene description.");
        renderDescriptionLink.defaultTo(ResourceIdentifier());
        clazz.addField(renderDescriptionLink);
 
        return clazz;
    }
};
 
}// end namespace ph::editor
 
#include "Designer/DesignerScene.ipp"