ProcgenScriptTarget.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditableTarget.h"
#include "editing/EditingProperty.h"
#include "editing/EditingTargetOperations.h"
#include "procgen/ParamSchema.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::procgen_editing {
 
using EditorDiagnostic = editing::Diagnostic;
using EditorStatus     = editing::Status;
using EditorValue      = editing::Value;
using editing::Result;
 
struct ProcgenScriptModuleSpec {
    std::string                      uri;
    std::string                      id;
    std::string                      displayName;
    std::string                      kind = "points";
    std::vector<procgen::ParamDescriptor> params;
};
 
class EVENGINE_API_ORCHESTRATION ProcgenScriptDocumentTarget final : public virtual editing::IEditableTarget,
                                                                     public editing::IDomainOperationTarget,
                                                                     public editing::IDomainOperationTargetStaging,
                                                                     public editing::IPropertyProvider {
public:
    explicit ProcgenScriptDocumentTarget(std::string id);
 
    static editing::CapabilityId propertyCapabilityId() {
        return editing::CapabilityId("eve.editor.target.procgen-script-properties");
    }
 
    editing::TargetId targetId() const override { return editing::TargetId(id_); }
    std::uint64_t     revision() const override { return revision_; }
    editing::EditRegion dirtyRegion() const override { return dirty_; }
    void              clearDirtyRegion() override { dirty_.clear(); }
    editing::TargetDescriptor describe() const override;
    void* queryCapability(const editing::CapabilityId&) override;
    Result<void> applyDomainOperation(const editing::DomainOperation&) override;
    std::unique_ptr<editing::IDomainOperationTarget> cloneDomainState() const override;
    Result<void> commitDomainState(std::unique_ptr<editing::IDomainOperationTarget>) override;
    eve::Result<eve::Revision> currentRevision(const editing::SelectionSnapshot&) const override;
    editing::PropertySchema schema(const editing::SelectionSnapshot&) const override;
    editing::PropertyReadResult read(const editing::SelectionSnapshot&,
                                     const editing::PropertyPath&) const override;
    Result<editing::DomainOperation> makeSet(const editing::SelectionSnapshot&,
                                                   const editing::PropertyPath&, const EditorValue&,
                                                   editing::PropertySetMode) const override;
    Result<editing::DomainOperation> makeReset(const editing::SelectionSnapshot&,
                                                     const editing::PropertyPath&) const override;
 
    static Result<ProcgenScriptModuleSpec> parseSpec(std::string uri, std::string id, std::string displayName,
                                                           std::string kind, const EditorValue& schema);
 
    Result<editing::DomainOperation> makeLoadModule(ProcgenScriptModuleSpec spec) const;
 
    const std::string&              uri() const { return uri_; }
    const std::string&              moduleId() const { return moduleId_; }
    const std::string&              displayName() const { return displayName_; }
    const std::string&              kind() const { return kind_; }
    const std::vector<procgen::ParamDescriptor>& params() const { return params_; }
    const EditorValue::Object&      values() const { return values_; }
    const procgen::ParamDescriptor* findParam(const std::string& key) const;
 
    std::vector<EditorDiagnostic> validate() const;
    EditorValue                   snapshotValue() const;
    Result<void>            loadSnapshot(const EditorValue&);
 
private:
    bool matches(const editing::SelectionSnapshot&) const;
    EditorValue contentValue() const;
    EditorValue schemaValue() const;
    static EditorValue defaultValue(const procgen::ParamDescriptor& param);
    static editing::PropertyType propertyType(procgen::ParamKind kind);
    void applySpec(ProcgenScriptModuleSpec spec);
 
    std::string                         id_;
    std::string                         uri_;
    std::string                         moduleId_;
    std::string                         displayName_;
    std::string                         kind_ = "points";
    std::vector<procgen::ParamDescriptor> params_;
    EditorValue::Object                 values_;
    editing::Revision                   revision_ = 1;
    editing::EditRegion                 dirty_;
};
 
}  // namespace eve::procgen_editing