ProcgenScriptEditor.h

浏览该文件的文档.

#pragma once
 
#include "editor/EditorAuthority.h"
#include "editor/EditorTransactionService.h"
#include "editor/EditorWorkspace.h"
#include "procgen/editing/ProcgenScriptTarget.h"
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::procgen {
class PointSet;
}
 
namespace eve::procgen_editor {
 
class EVENGINE_API_EDITORS ProcgenScriptEditor {
public:
    explicit ProcgenScriptEditor(std::string targetId);
 
    ProcgenScriptEditor(const ProcgenScriptEditor&)            = delete;
    ProcgenScriptEditor& operator=(const ProcgenScriptEditor&) = delete;
 
    const procgen_editing::ProcgenScriptDocumentTarget& target() const noexcept { return target_; }
 
    [[nodiscard]] procgen_editing::Result<void> configureWorkspace(editor::EditorWorkspace& workspace) const;
 
    [[nodiscard]] procgen_editing::Result<void> loadModule(procgen_editing::ProcgenScriptModuleSpec spec);
    [[nodiscard]] procgen_editing::Result<void> loadModule(std::string uri, std::string id,
                                                                 std::string displayName, std::string kind,
                                                                 const procgen_editing::EditorValue& schema);
 
    [[nodiscard]] procgen_editing::Result<void> setParam(std::string key,
                                                               procgen_editing::EditorValue value);
    [[nodiscard]] procgen_editing::Result<void> setInt(std::string key, int value);
    [[nodiscard]] procgen_editing::Result<void> setFloat(std::string key, double value);
    [[nodiscard]] procgen_editing::Result<void> setBool(std::string key, bool value);
    [[nodiscard]] procgen_editing::Result<void> setString(std::string key, std::string value);
 
    [[nodiscard]] procgen_editing::Result<void> publishPreview(const procgen::PointSet* points,
                                                                     std::string stage, std::uint64_t expectedRevision);
    [[nodiscard]] procgen_editing::Result<void> publishStage(const procgen::PointSet* points, std::string stage);
    [[nodiscard]] procgen_editing::Result<void> failPreview(std::string message,
                                                                  std::uint64_t expectedRevision);
    [[nodiscard]] procgen_editing::Result<void> selectStage(std::string stage);
    [[nodiscard]] procgen_editing::Result<void> setPointBudget(int budget);
    [[nodiscard]] procgen_editing::Result<void> setLive(bool enabled);
 
    [[nodiscard]] procgen_editing::Result<editor::TransactionReceipt> undo();
    [[nodiscard]] procgen_editing::Result<editor::TransactionReceipt> redo();
 
    bool          canUndo() const noexcept { return transactions_.canUndo(); }
    bool          canRedo() const noexcept { return transactions_.canRedo(); }
    bool          isDirty() const noexcept { return dirty_; }
    bool          isContinuousRebuild() const noexcept { return continuousRebuild_; }
    std::uint64_t revision() const noexcept { return target_.revision(); }
    std::uint64_t previewRevision() const noexcept { return previewRevision_; }
    int           pointBudget() const noexcept { return pointBudget_; }
    std::string   moduleId() const { return target_.moduleId(); }
    std::string   moduleUri() const { return target_.uri(); }
    std::string   displayName() const { return target_.displayName(); }
    std::string   kind() const { return target_.kind(); }
    std::string   selectedStage() const { return selectedStage_; }
    std::string   previewFailureSummary() const { return previewFailureSummary_; }
 
    int         paramCount() const { return static_cast<int>(target_.params().size()); }
    std::string paramKey(int index) const;
    std::string paramLabel(int index) const;
    std::string paramKind(int index) const;
    float       paramMinimum(int index) const;
    float       paramMaximum(int index) const;
    float       paramStep(int index) const;
    int         paramChoiceCount(int index) const;
    std::string paramChoice(int paramIndex, int choiceIndex) const;
    int         getInt(const std::string& key) const;
    float       getFloat(const std::string& key) const;
    bool        getBool(const std::string& key) const;
    std::string getString(const std::string& key) const;
 
    int         stageCount() const { return static_cast<int>(stageOrder_.size()); }
    std::string stageName(int index) const;
    int         pointCount() const;
    float       pointX(int index) const;
    float       pointZ(int index) const;
    std::uint32_t pointSeed(int index) const;
 
private:
    struct PreviewPoint {
        float         x    = 0;
        float         z    = 0;
        std::uint32_t seed = 1;
    };
 
    [[nodiscard]] procgen_editing::Result<void> commit(
        procgen_editing::Result<editing::DomainOperation> operation, std::string label);
    editor::SelectionSnapshot selection() const;
    const procgen::ParamDescriptor* paramAt(int index) const;
    [[nodiscard]] procgen_editing::Result<std::vector<PreviewPoint>> copyPoints(
        const procgen::PointSet* points) const;
    const std::vector<PreviewPoint>& displayedPoints() const;
 
    procgen_editing::ProcgenScriptDocumentTarget target_;
    editor::LocalWorldAuthority                  authority_;
    editor::LocalTransactionBackend              transactions_;
    std::unordered_map<std::string, std::vector<PreviewPoint>> stages_;
    std::vector<std::string>                     stageOrder_;
    std::string                                  selectedStage_;
    std::string                                  previewFailureSummary_;
    std::uint64_t                                txSequence_      = 0;
    std::uint64_t                                previewRevision_ = 0;
    int                                          pointBudget_     = 100000;
    bool                                         dirty_           = false;
    bool                                         continuousRebuild_ = false;
};
 
}  // namespace eve::procgen_editor