EditorExtension.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorCommandService.h"
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::editor {
 
enum class ExtensionAudience : std::uint32_t {
    None       = 0,
    Developer  = 1u << 0,
    Player     = 1u << 1,
    Admin      = 1u << 2,
    Automation = 1u << 3
};
 
constexpr ExtensionAudience operator|(ExtensionAudience left, ExtensionAudience right) {
    return static_cast<ExtensionAudience>(static_cast<std::uint32_t>(left) | static_cast<std::uint32_t>(right));
}
constexpr ExtensionAudience operator&(ExtensionAudience left, ExtensionAudience right) {
    return static_cast<ExtensionAudience>(static_cast<std::uint32_t>(left) & static_cast<std::uint32_t>(right));
}
constexpr bool hasAudience(ExtensionAudience value, ExtensionAudience audience) {
    return (value & audience) == audience;
}
 
struct ExtensionToolDescriptor {
    ToolId                    id;
    std::string               ownerModule;
    std::string               labelKey;
    std::string               category;
    std::vector<CapabilityId> targetRequirements;
    ExtensionAudience         audiences = ExtensionAudience::Developer;
};
 
struct ExtensionPaletteDescriptor {
    StableId               id;
    std::string            ownerModule;
    std::string            titleKey;
    std::vector<ToolId>    tools;
    std::vector<CommandId> commands;
    ExtensionAudience      audiences = ExtensionAudience::Developer;
};
 
struct ExtensionRuleDescriptor {
    RuleId            id;
    std::string       ownerModule;
    ExtensionAudience audiences = ExtensionAudience::Developer;
};
 
class IEditorExtensionRegistry {
public:
    virtual ~IEditorExtensionRegistry() = default;
    virtual Result<EditorValue> registerCommand(CommandDescriptor descriptor, EditorCommandHandler handler,
                                                      ExtensionAudience audiences) = 0;
    virtual Result<void> registerTool(ExtensionToolDescriptor descriptor) = 0;
    virtual Result<void> registerPalette(ExtensionPaletteDescriptor descriptor) = 0;
    virtual Result<void> registerRule(ExtensionRuleDescriptor descriptor) = 0;
};
 
class IGameEditorExtension {
public:
    virtual ~IGameEditorExtension() = default;
    virtual std::string ownerModule() const = 0;
    virtual void registerEditor(IEditorExtensionRegistry& registry) = 0;
};
 
class EVENGINE_API_ORCHESTRATION EditorExtensionRegistry final : public IEditorExtensionRegistry {
public:
    explicit EditorExtensionRegistry(EditorCommandService* commands) : commands_(commands) {}
 
    Result<void> load(IGameEditorExtension& extension);
    std::size_t unload(const std::string& ownerModule);
    void configureProfile(HostProfile& profile) const;
 
    std::vector<ExtensionToolDescriptor> tools(const HostProfile& profile) const;
    std::vector<ExtensionPaletteDescriptor> palettes(const HostProfile& profile) const;
    std::vector<ExtensionRuleDescriptor> rules(const HostProfile& profile) const;
 
    Result<EditorValue> registerCommand(CommandDescriptor descriptor, EditorCommandHandler handler,
                                              ExtensionAudience audiences) override;
    Result<void>        registerTool(ExtensionToolDescriptor descriptor) override;
    Result<void>        registerPalette(ExtensionPaletteDescriptor descriptor) override;
    Result<void>        registerRule(ExtensionRuleDescriptor descriptor) override;
 
private:
    struct CommandVisibility {
        CommandId         id;
        std::string       ownerModule;
        ExtensionAudience audiences;
    };
 
    static ExtensionAudience  audienceFor(const HostProfile& profile);
    static Result<void> invalid(const char* rule, std::string message);
 
    EditorCommandService*                   commands_ = nullptr;
    std::string                             activeOwner_;
    std::vector<CommandVisibility>          commandVisibility_;
    std::vector<ExtensionToolDescriptor>    tools_;
    std::vector<ExtensionPaletteDescriptor> palettes_;
    std::vector<ExtensionRuleDescriptor>    rules_;
};
 
}  // namespace eve::editor