VegetationConverterController.cpp

浏览该文件的文档.

#include "editor/VegetationConverterController.h"
 
namespace eve::editor {
namespace {
std::vector<EditorDiagnostic> project(const std::vector<Diagnostic>& diagnostics) { return diagnostics; }
}  // namespace
 
Result<asset_import::PreparedAssetImport> NativeVegetationConversionPreparer::prepare(
    const asset_import::UnityVegetationBatchImportRequest& request) const {
    return asset_import::prepareUnityVegetationConversionBatch(request);
}
 
VegetationConverterController::VegetationConverterController(const IVegetationConversionPreparer& preparer,
                                                             IVegetationConversionPublisher&      publisher)
    : preparer_(preparer), publisher_(publisher) {}
 
Result<void> VegetationConverterController::setRequest(asset_import::UnityVegetationBatchImportRequest request,
                                                             std::uint64_t expectedPublicationGeneration) {
    if (request.package.packageId.isNil() || request.package.packageName.empty() ||
        request.package.packageVersion.empty() || request.objects.empty())
        return editing::failed<void>(EditorStatus::Rejected, RuleId("editor.vegetation-converter.request"),
                                     "Vegetation conversion requires package identity and at least one object");
    request_ = std::move(request);
    candidate_.reset();
    expectedPublicationGeneration_ = expectedPublicationGeneration;
    ++state_.requestRevision;
    state_.preparedRevision      = 0;
    state_.publicationGeneration = 0;
    state_.objectCount           = request_->objects.size();
    state_.assetCount            = 0;
    state_.findingCount          = 0;
    state_.diagnostics.clear();
    state_.phase = VegetationConverterState::Phase::Dirty;
    return editing::applied<void>();
}
 
Result<void> VegetationConverterController::prepare() {
    if (!request_)
        return editing::failed<void>(EditorStatus::Rejected, RuleId("editor.vegetation-converter.no-request"),
                                     "Set a vegetation conversion request before preparing it");
    auto prepared = preparer_.prepare(*request_);
    if (!prepared.ok()) {
        candidate_.reset();
        state_.preparedRevision = 0;
        state_.assetCount       = 0;
        state_.findingCount     = 0;
        state_.diagnostics      = project(prepared.diagnostics());
        state_.phase            = VegetationConverterState::Phase::Error;
        return Result<void>::failure(prepared.status());
    }
    candidate_              = std::move(prepared).takeValue();
    state_.preparedRevision = state_.requestRevision;
    state_.assetCount       = candidate_->manifest.assets.size();
    state_.findingCount     = candidate_->findings.size();
    state_.diagnostics.clear();
    state_.phase = VegetationConverterState::Phase::Prepared;
    return editing::applied<void>();
}
 
Result<std::uint64_t> VegetationConverterController::publish() {
    if (!candidate_ || state_.preparedRevision != state_.requestRevision)
        return editing::failed<std::uint64_t>(EditorStatus::Conflict,
                                              RuleId("editor.vegetation-converter.stale-candidate"),
                                              "Prepare the current vegetation request before publishing it");
    auto published = publisher_.publish(*candidate_, expectedPublicationGeneration_);
    if (!published.ok()) {
        state_.diagnostics = published.diagnostics();
        state_.phase       = VegetationConverterState::Phase::Error;
        return published;
    }
    expectedPublicationGeneration_ = published.value();
    state_.publicationGeneration   = published.value();
    state_.diagnostics.clear();
    state_.phase = VegetationConverterState::Phase::Published;
    return published;
}
 
Result<void> VegetationConverterController::clear() {
    request_.reset();
    candidate_.reset();
    state_                         = {};
    expectedPublicationGeneration_ = 0;
    return editing::applied<void>();
}
 
VegetationConverterState VegetationConverterController::state() const { return state_; }
 
}  // namespace eve::editor