SceneComponentPayload.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "scene/editing/SceneEditingTypes.h"
 
#include <functional>
#include <map>
#include <string>
#include <vector>
 
namespace eve::scene_editing {
 
enum class SceneComponentChange { Changed, Unchanged };
 
struct SceneComponentPayloadRef {
    TargetId target;
    ObjectId object;
    StableId component;
    std::string type;
    std::uint64_t generation = 0;
    Revision revision = 0;
 
    auto operator<=>(const SceneComponentPayloadRef&) const = default;
};
 
class ISceneComponentPayloadProvider : public IPropertyProvider {
public:
    ~ISceneComponentPayloadProvider() override = default;
 
    virtual const std::string& componentType() const = 0;
    virtual std::vector<SceneComponentPayloadRef> components(const TargetId& scene,
                                                              const ObjectId& object) const = 0;
    virtual Result<IDomainOperationTarget*> payloadOperationTarget(
        const SelectionSnapshot& selection) const = 0;
    virtual std::vector<EditorDiagnostic> validateComponent(const SceneComponentPayloadRef& component) const = 0;
};
 
class EVENGINE_API_BACKENDS SceneComponentPropertyBindings final : public ISceneComponentPayloadProvider {
public:
    using Validator = std::function<std::vector<EditorDiagnostic>()>;
 
    explicit SceneComponentPropertyBindings(std::string componentType);
    const std::string& componentType() const override { return componentType_; }
 
    Result<void> bind(SceneComponentPayloadRef component,
                            SelectionItem moduleSelection,
                            IPropertyProvider* properties,
                            IDomainOperationTarget* operations,
                            Validator validator = {});
    SceneComponentChange unbind(const TargetId& scene, const StableId& component);
 
    std::vector<SceneComponentPayloadRef> components(const TargetId& scene,
                                                      const ObjectId& object) const override;
    Result<IDomainOperationTarget*> payloadOperationTarget(
        const SelectionSnapshot& selection) const override;
    std::vector<EditorDiagnostic> validateComponent(
        const SceneComponentPayloadRef& component) const override;
    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:
    struct Binding {
        SceneComponentPayloadRef component;
        SelectionItem moduleSelection;
        IPropertyProvider* properties = nullptr;
        IDomainOperationTarget* operations = nullptr;
        Validator validator;
    };
 
    Result<std::pair<const Binding*, SelectionSnapshot>> translate(
        const SelectionSnapshot& selection) const;
    const Binding* find(const TargetId& scene, const StableId& component) const;
 
    std::string componentType_;
    std::vector<Binding> bindings_;
};
 
class ISceneComponentPayloadTarget {
public:
    virtual ~ISceneComponentPayloadTarget() = default;
    static CapabilityId editorCapabilityId() {
        return CapabilityId("eve.editor.target.scene-component-payloads");
    }
    virtual Result<std::vector<SceneComponentPayloadRef>> componentPayloads(
        const TargetId& scene, const ObjectId& object) const = 0;
    virtual Result<IPropertyProvider*> propertyProvider(const SelectionSnapshot& selection) const = 0;
    virtual Result<IDomainOperationTarget*> operationTarget(const SelectionSnapshot& selection) const = 0;
    virtual Result<std::vector<EditorDiagnostic>> validatePayload(
        const SceneComponentPayloadRef& component) const = 0;
};
 
class EVENGINE_API_BACKENDS SceneComponentPayloadRegistry final : public ISceneComponentPayloadTarget {
public:
    Result<void> registerProvider(ISceneComponentPayloadProvider* provider);
    SceneComponentChange unregisterProvider(ISceneComponentPayloadProvider* provider);
 
    Result<std::vector<SceneComponentPayloadRef>> componentPayloads(
        const TargetId& scene, const ObjectId& object) const override;
    Result<IPropertyProvider*> propertyProvider(const SelectionSnapshot& selection) const override;
    Result<IDomainOperationTarget*> operationTarget(const SelectionSnapshot& selection) const override;
    Result<std::vector<EditorDiagnostic>> validatePayload(
        const SceneComponentPayloadRef& component) const override;
 
private:
    Result<ISceneComponentPayloadProvider*> resolve(const SelectionSnapshot& selection) const;
    std::map<std::string, ISceneComponentPayloadProvider*> providers_;
};
 
EVENGINE_API_BACKENDS Result<SelectionSnapshot> makeSceneComponentSelection(
    std::string channel, const std::vector<SceneComponentPayloadRef>& components, std::uint64_t sequence = 0);
 
}  // namespace eve::scene_editing