EditorMaterialStudio.cpp

浏览该文件的文档.

#include "graphics/material/editor/EditorMaterialStudio.h"
 
#include <cmath>
#include <utility>
 
namespace eve::editor {
namespace {
 
Result<void> noStudioChange() {
    return eve::editing::noOp();
}
 
}  // namespace
 
MaterialStudioController::MaterialStudioController(DocumentId document, MaterialPublishingTarget& target,
                                                   IEditorTransactionBackend& transactions,
                                                   MaterialPreviewService& previews, IMaterialPreviewRenderer& renderer)
    : document_(std::move(document)),
      target_(target),
      transactions_(transactions),
      previews_(previews),
      renderer_(renderer) {}
 
Result<void> MaterialStudioController::setPreviewSettings(MaterialPreviewSettings settings) {
    settings_     = std::move(settings);
    previewDirty_ = true;
    return eve::editing::applied<void>();
}
 
Result<void> MaterialStudioController::beginInteraction(PropertyPath path) {
    if (activeProperty_ || transactions_.active())
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.material.studio-interaction-active"),
                                          "Finish or cancel the active material edit first");
    const auto selection  = selectionFor(target_.authoringTarget());
    const auto descriptor = target_.authoringTarget().schema(selection).find(path);
    if (!descriptor)
        return eve::editing::failed<void>(EditorStatus::NotFound, RuleId("editor.material.studio-property"),
                                          "Material property is not present in the schema: " + path.value());
    draft_          = std::make_unique<MaterialDocumentTarget>(target_.authoringTarget());
    activeProperty_ = std::move(path);
    finalValue_.reset();
    diagnostics_.clear();
    return eve::editing::applied<void>();
}
 
Result<void> MaterialStudioController::updateInteraction(EditorValue value) {
    if (!draft_ || !activeProperty_)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.material.studio-no-interaction"),
                                          "Begin a material interaction before updating it");
    auto operation = draft_->makeSet(selectionFor(*draft_), *activeProperty_, value, PropertySetMode::Absolute);
    if (!operation.ok()) {
        diagnostics_ = operation.diagnostics();
        return Result<void>::failure(operation.status());
    }
    auto applied = draft_->applyDomainOperation(operation.value());
    if (!applied.ok()) {
        diagnostics_ = applied.diagnostics();
        return applied;
    }
    finalValue_   = std::move(value);
    diagnostics_  = draft_->validate();
    previewDirty_ = true;
    return eve::editing::applied<void>();
}
 
Result<TransactionReceipt> MaterialStudioController::commitInteraction() {
    if (!draft_ || !activeProperty_ || !finalValue_)
        return eve::editing::failed<TransactionReceipt>(EditorStatus::Rejected,
                                                        RuleId("editor.material.studio-no-final-value"),
                                                        "The material interaction has no value to commit");
    auto operation = target_.authoringTarget().makeSet(selectionFor(target_.authoringTarget()), *activeProperty_,
                                                       *finalValue_, PropertySetMode::Absolute);
    if (!operation.ok())
        return Result<TransactionReceipt>::failure(operation.status());
    TransactionSpec specification;
    specification.id           = TransactionId("material-studio-" + std::to_string(++transactionSequence_));
    specification.label        = "Edit material " + activeProperty_->value();
    specification.target       = TargetId(target_.targetId());
    specification.baseRevision = target_.revision();
    specification.mergeKey     = operation.value().mergeKey;
    auto begun                 = transactions_.begin(std::move(specification));
    if (!begun.ok())
        return eve::editing::failed<TransactionReceipt>(begun.code(), RuleId("editor.material.studio-begin"),
                                                        "Could not begin the material transaction");
    auto appended = transactions_.append(std::move(operation).takeValue());
    if (!appended.ok()) {
        [[maybe_unused]] auto discarded = transactions_.discard();
        return eve::editing::failed<TransactionReceipt>(appended.code(), RuleId("editor.material.studio-append"),
                                                        "Could not append the material edit");
    }
    auto previewed = transactions_.preview();
    if (!previewed.ok()) {
        [[maybe_unused]] auto discarded = transactions_.discard();
        return eve::editing::failed<TransactionReceipt>(previewed.code(), RuleId("editor.material.studio-preflight"),
                                                        "Material transaction preflight failed");
    }
    auto committed = transactions_.commit();
    if (!committed.ok()) return committed;
    clearInteraction();
    previewDirty_ = true;
    return committed;
}
 
Result<void> MaterialStudioController::cancelInteraction() {
    if (!draft_) return noStudioChange();
    clearInteraction();
    previewDirty_ = true;
    diagnostics_  = target_.authoringTarget().validate();
    return eve::editing::applied<void>();
}
 
Result<void> MaterialStudioController::tick(std::uint64_t monotonicMilliseconds) {
    if (!previewDirty_) return noStudioChange();
    if (hasPreviewTimestamp_ && monotonicMilliseconds < lastPreviewMilliseconds_)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.material.studio-time-regressed"),
                                          "Material preview time must be monotonic");
    if (hasPreviewTimestamp_ && monotonicMilliseconds - lastPreviewMilliseconds_ < previewIntervalMilliseconds_)
        return noStudioChange();
    auto rendered = refreshPreview();
    if (rendered.ok()) {
        lastPreviewMilliseconds_ = monotonicMilliseconds;
        hasPreviewTimestamp_     = true;
    }
    return rendered;
}
 
Result<void> MaterialStudioController::refreshPreview() {
    return renderPreview(draft_ ? *draft_ : target_.authoringTarget());
}
 
Result<void> MaterialStudioController::setPreviewRate(double framesPerSecond) {
    if (!std::isfinite(framesPerSecond) || framesPerSecond < 1.0 || framesPerSecond > 240.0)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.material.studio-preview-rate"),
                                          "Material preview rate must be between 1 and 240 Hz");
    previewIntervalMilliseconds_ = static_cast<std::uint64_t>(std::ceil(1000.0 / framesPerSecond));
    return eve::editing::applied<void>();
}
 
MaterialStudioState MaterialStudioController::state() const {
    MaterialStudioState result;
    result.interactionActive = draft_ != nullptr;
    result.previewDirty      = previewDirty_;
    result.activeProperty    = activeProperty_.value_or(PropertyPath{});
    result.documentRevision  = target_.revision();
    result.previewRevision   = previewRevision_;
    result.previewArtifact   = previewArtifact_;
    result.diagnostics       = diagnostics_;
    return result;
}
 
SelectionSnapshot MaterialStudioController::selectionFor(const MaterialDocumentTarget& material) const {
    SelectionSnapshot selection;
    selection.channel = "asset";
    SelectionItem item;
    item.domain = SelectionDomain::Asset;
    item.target = TargetId(material.targetId());
    item.item   = StableId(material.targetId().value());
    item.type   = "graphics.material";
    selection.items.push_back(item);
    selection.primary = item;
    return selection;
}
 
Result<void> MaterialStudioController::renderPreview(const MaterialDocumentTarget& material) {
    auto task = previews_.render(document_, material, settings_, renderer_);
    if (!task.ok()) {
        diagnostics_ = task.diagnostics();
        return eve::editing::failed<void>(task.code(), RuleId("editor.material.studio-preview"),
                                          "Material preview request was rejected");
    }
    auto result = previews_.result(task.value());
    if (!result.ok()) {
        diagnostics_ = result.diagnostics();
        return eve::editing::failed<void>(result.code(), RuleId("editor.material.studio-preview-result"),
                                          "Material preview result is unavailable");
    }
    auto published = previews_.publish(document_, material.revision(), task.value());
    diagnostics_   = result.value().diagnostics;
    if (!published.ok()) {
        diagnostics_.insert(diagnostics_.end(), published.diagnostics().begin(),
                            published.diagnostics().end());
        return published;
    }
    previewArtifact_ = result.value().artifact;
    previewRevision_ = material.revision();
    previewDirty_    = false;
    return eve::editing::applied<void>();
}
 
void MaterialStudioController::clearInteraction() {
    draft_.reset();
    activeProperty_.reset();
    finalValue_.reset();
}
 
}  // namespace eve::editor