SceneTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "scene/editing/SceneEditingCommands.h"
#include "scene/editing/SceneEditingTypes.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::scene_editing {
 
class SceneComponentPayloadRegistry;
 
struct SceneObjectSnapshot {
    ObjectId            id;
    ObjectId            parent;
    std::string         name;
    SceneTransformValue transform;
};
 
struct CreateSceneObjectRequest {
    ObjectId            id;
    ObjectId            parent;
    std::string         name;
    SceneTransformValue transform;
};
 
class ISceneHierarchyEditTarget {
public:
    virtual ~ISceneHierarchyEditTarget() = default;
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.scene-hierarchy"); }
    virtual Result<SceneObjectSnapshot> sceneObject(const ObjectId& id) const = 0;
    virtual std::vector<ObjectId> sceneChildren(const ObjectId& parent) const = 0;
    virtual Result<DomainOperation> makeCreate(const CreateSceneObjectRequest& request) const = 0;
    virtual Result<DomainOperation> makeDelete(const ObjectId& id) const = 0;
    virtual Result<DomainOperation> makeRename(const ObjectId& id, const std::string& name) const = 0;
    virtual Result<DomainOperation> makeReparent(const ObjectId& id, const ObjectId& parent) const = 0;
};
 
struct SceneComponentLinkSnapshot {
    std::string kind;
    int syncMode = 0;
    bool targetAlive = false;
};
 
class ISceneComponentInspector {
public:
    virtual ~ISceneComponentInspector() = default;
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.scene-components"); }
    virtual Result<std::vector<SceneComponentLinkSnapshot>> componentLinks(
        const ObjectId& object) const = 0;
};
 
class EVENGINE_API_BACKENDS SceneTargetBase : public ::eve::editing::EditableTargetState,
                                              public virtual IEditableTarget,
                                              public IDomainOperationTarget,
                                              public IDomainOperationTargetStaging,
                                              public eve::editing::IEditingSnapshotProvider,
                                              public ISceneHierarchyEditTarget,
                                              public ITransformEditTarget {
public:
    SceneTargetBase(std::string id, std::string type);
    ~SceneTargetBase() override = default;
 
    TargetId           targetId() const override { return TargetId(id_); }
    TargetDescriptor   describe() const override;
    void*              queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
 
    Result<SceneObjectSnapshot> sceneObject(const ObjectId& id) const override;
    std::vector<ObjectId>             sceneChildren(const ObjectId& parent) const override;
    Result<DomainOperation>     makeCreate(const CreateSceneObjectRequest& request) const override;
    Result<DomainOperation>     makeDelete(const ObjectId& id) const override;
    Result<DomainOperation>     makeRename(const ObjectId& id, const std::string& name) const override;
    Result<DomainOperation>     makeReparent(const ObjectId& id, const ObjectId& parent) const override;
    Result<SceneTransformValue> readTransform(const ObjectId& id) const override;
    Result<DomainOperation>     makeSetTransform(const ObjectId&            id,
                                                       const SceneTransformValue& transform) const override;
    void bindComponentPayloads(SceneComponentPayloadRegistry* registry) { componentPayloads_ = registry; }
    EditorValue snapshotValue() const override;
    [[nodiscard]] Result<DomainOperation> makeRestore(const EditorValue& snapshot) const;
 
private:
    friend class ScenePropertyProvider;
    static EditorValue                       transformValue(const SceneTransformValue& transform);
    static Result<SceneTransformValue> parseTransform(const EditorValue& value);
    static Result<SceneObjectSnapshot> parseObject(const EditorValue& value);
    static EditorValue                       objectValue(const SceneObjectSnapshot& object);
    static Result<std::map<ObjectId, SceneObjectSnapshot>> parseSnapshot(const EditorValue& value);
 
    std::string                             id_;
    std::string                             type_;
    std::map<ObjectId, SceneObjectSnapshot> objects_;
    SceneComponentPayloadRegistry*          componentPayloads_ = nullptr;
};
 
class SceneDocumentTarget final : public SceneTargetBase {
public:
    explicit SceneDocumentTarget(std::string id) : SceneTargetBase(std::move(id), "scene-document") {}
};
 
class RuntimeWorldTarget final : public SceneTargetBase {
public:
    explicit RuntimeWorldTarget(std::string id) : SceneTargetBase(std::move(id), "runtime-world") {}
};
 
}  // namespace eve::scene_editing
 
namespace eve::scene {
class SceneHost;
}
 
namespace eve::scene_editing {
 
class EVENGINE_API_BACKENDS SceneHostEditorTarget final : public SceneTargetBase, public ISceneComponentInspector {
public:
    SceneHostEditorTarget(std::string id, scene::SceneHost* host);
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    void* queryCapability(const CapabilityId& capability) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(
        std::unique_ptr<IDomainOperationTarget> candidate) override;
    [[nodiscard]] scene::SceneHost*                       host() const;
    Result<std::vector<SceneComponentLinkSnapshot>> componentLinks(
        const ObjectId& object) const override;
 
private:
    Result<void> synchronizeHost(const SceneTargetBase& desired);
    ecs::EntityHandle  hostHandle_{};
    bool               staging_ = false;
};
 
class EVENGINE_API_BACKENDS ScenePlacementToolLogic {
public:
    Result<DomainOperation> plan(IEditableTarget& target, const CreateSceneObjectRequest& request) const;
};
 
class EVENGINE_API_BACKENDS SceneHierarchyToolLogic {
public:
    Result<DomainOperation> planDelete(IEditableTarget& target, const ObjectId& object) const;
    Result<DomainOperation> planRename(IEditableTarget& target, const ObjectId& object,
                                             const std::string& name) const;
    Result<DomainOperation> planReparent(IEditableTarget& target, const ObjectId& object,
                                               const ObjectId& parent) const;
};
 
class EVENGINE_API_BACKENDS SceneTransformToolLogic {
public:
    Result<DomainOperation> plan(IEditableTarget& target, const ObjectId& object,
                                       const SceneTransformValue& transform) const;
};
 
class EVENGINE_API_BACKENDS ScenePropertyProvider final : public IPropertyProvider {
public:
    explicit ScenePropertyProvider(const SceneTargetBase* target) : target_(target) {}
 
    eve::Result<eve::Revision> currentRevision(const SelectionSnapshot& selection) const override;
    PropertySchema schema(const SelectionSnapshot& selection) const override;
    PropertyReadResult read(const SelectionSnapshot& selection, const PropertyPath& path) const override;
    Result<DomainOperation> makeSet(const SelectionSnapshot& selection, const PropertyPath& path,
                                          const EditorValue& value, PropertySetMode mode) const override;
    Result<DomainOperation> makeReset(const SelectionSnapshot& selection,
                                            const PropertyPath& path) const override;
 
private:
    const SceneTargetBase* target_ = nullptr;
};
 
}  // namespace eve::scene_editing