StylizeTarget.cpp

浏览该文件的文档.

#include "stylize/editing/StylizeTarget.h"
 
#include "stylize/StyleShaders.h"
 
#include <algorithm>
#include <cmath>
#include <set>
#include <utility>
 
namespace eve::stylize_editing {
namespace {
const EditorValue* field(const EditorValue& v, const char* k) {
    const auto* o = v.getIf<EditorValue::Object>();
    if (!o) return nullptr;
    auto i = o->find(k);
    return i == o->end() ? nullptr : &i->second;
}
EditorValue passValue(const StylizePassValue& p) {
    EditorValue::Object overrides;
    for (const auto& [name, value] : p.overrides) overrides[name] = value;
    return EditorValue::Object{{"id", p.id.value()},
                               {"style", p.style},
                               {"enabled", p.enabled},
                               {"priority", int64_t{p.priority}},
                               {"overrides", std::move(overrides)}};
}
Result<StylizePassValue> parsePass(const EditorValue& v) {
    const auto *idv = field(v, "id"), *stylev = field(v, "style"), *enabledv = field(v, "enabled"),
               *priorityv = field(v, "priority"), *overridesv = field(v, "overrides");
    const auto* id        = idv ? idv->getIf<std::string>() : nullptr;
    const auto* style     = stylev ? stylev->getIf<std::string>() : nullptr;
    const auto* enabled   = enabledv ? enabledv->getIf<bool>() : nullptr;
    const auto* priority  = priorityv ? priorityv->getIf<int64_t>() : nullptr;
    const auto* overrides = overridesv ? overridesv->getIf<EditorValue::Object>() : nullptr;
    if (!id || id->empty() || !style || !stylize::isKnownStyle(*style) || !enabled || !priority ||
        *priority < -100000 || *priority > 100000 || !overrides)
        return eve::editing::failed<StylizePassValue>(EditorStatus::Rejected, RuleId("editor.stylize.pass"),
                                                      "Invalid stylize pass fields");
    StylizePassValue p{ObjectId(*id), *style, *enabled, static_cast<int>(*priority), {}};
    for (const auto& [name, value] : *overrides) {
        const auto* n = value.getIf<double>();
        const auto* d = stylize::findStyleParameter(*style, name);
        if (!n || !std::isfinite(*n) || !d || *n < d->minValue || *n > d->maxValue)
            return eve::editing::failed<StylizePassValue>(EditorStatus::Rejected, RuleId("editor.stylize.parameter"),
                                                          "Invalid stylize parameter override");
        p.overrides[name] = *n;
    }
    return eve::editing::applied<StylizePassValue>(std::move(p));
}
bool hasError(const std::vector<EditorDiagnostic>& d) {
    return std::any_of(d.begin(), d.end(), [](const auto& v) { return v.severity() == DiagnosticSeverity::Error; });
}
PropertyDescriptor property(const std::string& path, PropertyType type, EditorValue value, const char* category) {
    PropertyDescriptor d;
    d.path           = PropertyPath(path);
    d.displayNameKey = "editor.stylize." + path;
    d.category       = category;
    d.type           = type;
    d.flags          = PropertyFlag::Runtime;
    d.defaultValue   = std::move(value);
    if (path == "pass.priority") {
        d.numeric.minimum = -100000;
        d.numeric.maximum = 100000;
    }
    return d;
}
}  // namespace
 
StylizeRecipeTarget::StylizeRecipeTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor StylizeRecipeTarget::describe() const {
    return {TargetId(id_),
            "stylize-recipe",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.stylize-properties")}};
}
void* StylizeRecipeTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.stylize-properties") ? static_cast<IPropertyProvider*>(this) : nullptr;
}
bool StylizeRecipeTarget::matches(const SelectionSnapshot& s) const {
    if (s.items.empty()) return false;
    for (const auto& i : s.items)
        if (i.target != TargetId(id_) || !passes_.contains(ObjectId(i.item.value()))) return false;
    return true;
}
eve::Result<eve::Revision> StylizeRecipeTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "Stylize selection mismatch", "editor.stylize.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema StylizeRecipeTarget::schema(const SelectionSnapshot& s) const {
    PropertySchema schema;
    schema.typeId     = "stylize.pass";
    schema.properties = {property("pass.enabled", PropertyType::Bool, true, "pass"),
                         property("pass.priority", PropertyType::Int, int64_t{0}, "pass")};
    if (!matches(s)) return schema;
    const std::string style = passes_.at(ObjectId(s.items.front().item.value())).style;
    for (const auto& i : s.items)
        if (passes_.at(ObjectId(i.item.value())).style != style) return schema;
    for (int index = 0; index < stylize::styleParamCount(style); ++index) {
        const auto* d = stylize::styleParameterAt(style, index);
        auto p = property("parameter." + std::string(d->id), PropertyType::Float, static_cast<double>(d->defaultValue),
                          "parameters");
        p.numeric.minimum = d->minValue;
        p.numeric.maximum = d->maxValue;
        schema.properties.push_back(std::move(p));
    }
    return schema;
}
PropertyReadResult StylizeRecipeTarget::read(const SelectionSnapshot& s, const PropertyPath& path) const {
    if (!matches(s) || !schema(s).find(path)) return {};
    std::optional<EditorValue> common;
    for (const auto& i : s.items) {
        const auto& p = passes_.at(ObjectId(i.item.value()));
        EditorValue value;
        if (path == PropertyPath("pass.enabled"))
            value = p.enabled;
        else if (path == PropertyPath("pass.priority"))
            value = int64_t{p.priority};
        else {
            const std::string name  = path.value().substr(std::string("parameter.").size());
            auto              found = p.overrides.find(name);
            const auto*       d     = stylize::findStyleParameter(p.style, name);
            value                   = found == p.overrides.end() ? EditorValue(static_cast<double>(d->defaultValue))
                                                                 : EditorValue(found->second);
        }
        if (!common)
            common = value;
        else if (*common != value)
            return {PropertyReadState::Mixed, {}, {}};
    }
    return {PropertyReadState::Value, *common, {}};
}
EditorValue StylizeRecipeTarget::contentValue() const {
    EditorValue::Array array;
    for (const auto& id : order_) array.push_back(passValue(passes_.at(id)));
    return EditorValue::Object{{"passes", std::move(array)}};
}
Result<DomainOperation> StylizeRecipeTarget::replacement(EditorValue payload,
                                                                std::string propertyName) const {
    DomainOperation op;
    op.type        = "stylize.recipe.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(payload);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    if (!propertyName.empty()) op.affectedProperties.push_back(propertyName);
    op.mergeKey = "stylize:" + id_ + ":" + (propertyName.empty() ? "structure" : propertyName);
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> StylizeRecipeTarget::makeSet(const SelectionSnapshot& s, const PropertyPath& path,
                                                           const EditorValue& value, PropertySetMode mode) const {
    if (mode == PropertySetMode::Reset) return makeReset(s, path);
    auto d = schema(s).find(path);
    if (!matches(s) || !d || mode != PropertySetMode::Absolute)
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.set"),
                                                     "Stylize property requires matching absolute selection");
    auto checked = validatePropertyValue(*d, value);
    if (!checked.ok())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.value"),
                                                     "Stylize property is outside its metadata range");
    auto candidate = *this;
    for (const auto& i : s.items) {
        auto& p = candidate.passes_[ObjectId(i.item.value())];
        if (path == PropertyPath("pass.enabled"))
            p.enabled = *value.getIf<bool>();
        else if (path == PropertyPath("pass.priority"))
            p.priority = static_cast<int>(*value.getIf<int64_t>());
        else
            p.overrides[path.value().substr(10)] = *value.getIf<double>();
    }
    if (hasError(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.invalid"),
                                                     "Stylize edit produces an invalid recipe");
    return replacement(candidate.contentValue(), path.value());
}
Result<DomainOperation> StylizeRecipeTarget::makeReset(const SelectionSnapshot& s,
                                                             const PropertyPath&      path) const {
    auto d = schema(s).find(path);
    if (!d)
        return eve::editing::failed<DomainOperation>(EditorStatus::Unsupported, RuleId("editor.stylize.property"),
                                                     "Unknown stylize property");
    if (path.value().starts_with("parameter.")) {
        auto candidate = *this;
        for (const auto& i : s.items)
            candidate.passes_[ObjectId(i.item.value())].overrides.erase(path.value().substr(10));
        return replacement(candidate.contentValue(), path.value());
    }
    return makeSet(s, path, d->defaultValue, PropertySetMode::Absolute);
}
Result<DomainOperation> StylizeRecipeTarget::makeCreate(const ObjectId& id, const std::string& style) const {
    if (id.empty() || passes_.contains(id) || !stylize::isKnownStyle(style))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.create"),
                                                     "Stylize pass ID or style is invalid");
    auto candidate        = *this;
    candidate.passes_[id] = {id, style, true, static_cast<int>(order_.size()), {}};
    candidate.order_.push_back(id);
    if (hasError(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.stage"),
                                                     "Stylize recipe cannot mix post and mesh stages");
    return replacement(candidate.contentValue());
}
Result<DomainOperation> StylizeRecipeTarget::makeDelete(const ObjectId& id) const {
    if (!passes_.contains(id))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.stylize.pass"),
                                                     "Stylize pass does not exist");
    auto candidate = *this;
    candidate.passes_.erase(id);
    std::erase(candidate.order_, id);
    return replacement(candidate.contentValue());
}
Result<DomainOperation> StylizeRecipeTarget::makeMove(const ObjectId& id, std::size_t index) const {
    if (!passes_.contains(id) || index >= order_.size())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.stylize.move"),
                                                     "Stylize move target or index is invalid");
    auto candidate = *this;
    std::erase(candidate.order_, id);
    candidate.order_.insert(candidate.order_.begin() + static_cast<std::ptrdiff_t>(index), id);
    for (std::size_t i = 0; i < candidate.order_.size(); ++i)
        candidate.passes_[candidate.order_[i]].priority = static_cast<int>(i);
    return replacement(candidate.contentValue());
}
Result<void> StylizeRecipeTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "stylize.recipe.replace.v1")
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.operation"),
                                          "Stylize operation mismatch");
    const auto* p     = field(op.payload, "passes");
    const auto* array = p ? p->getIf<EditorValue::Array>() : nullptr;
    if (!array || array->size() > 64)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.payload"),
                                          "Stylize recipe payload is invalid or exceeds 64 passes");
    StylizeRecipeTarget candidate(id_);
    for (const auto& entry : *array) {
        auto parsed = parsePass(entry);
        if (!parsed.ok() || candidate.passes_.contains(parsed.value().id))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.pass"),
                                              "Stylize recipe contains invalid or duplicate passes");
        candidate.order_.push_back(parsed.value().id);
        candidate.passes_.emplace(parsed.value().id, parsed.value());
    }
    if (hasError(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.stylize.invalid"),
                                          "Stylize recipe violates stage or parameter rules");
    passes_ = std::move(candidate.passes_);
    order_  = std::move(candidate.order_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> StylizeRecipeTarget::cloneDomainState() const {
    return std::make_unique<StylizeRecipeTarget>(*this);
}
Result<void> StylizeRecipeTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) {
    auto* t = dynamic_cast<StylizeRecipeTarget*>(candidate.get());
    if (!t || t->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.stylize.candidate"),
                                          "Stylize candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
std::vector<StylizePassValue> StylizeRecipeTarget::passes() const {
    std::vector<StylizePassValue> result;
    for (const auto& id : order_) result.push_back(passes_.at(id));
    return result;
}
std::vector<EditorDiagnostic> StylizeRecipeTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    std::string                   stage;
    for (const auto& id : order_) {
        const auto& p          = passes_.at(id);
        const auto* definition = stylize::findStyleDefinition(p.style);
        if (!definition) {
            d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
                RuleId("editor.stylize.unknown-style"), DiagnosticSeverity::Error, "Unknown style: " + p.style));
            continue;
        }
        if (!p.enabled) continue;
        const std::string current = graphics::postEffectStageName(definition->stage);
        if (stage.empty())
            stage = current;
        else if (stage != current)
            d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
                RuleId("editor.stylize.mixed-stage"), DiagnosticSeverity::Error,
                "Enabled recipe passes must share one pipeline stage"));
        if (!definition->post)
            d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
                RuleId("editor.stylize.mesh-in-recipe"), DiagnosticSeverity::Error,
                "Post recipe cannot contain a mesh-only style: " + p.style));
    }
    if (order_.empty())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.stylize.empty"), DiagnosticSeverity::Warning, "Stylize recipe has no passes"));
    return d;
}
EditorValue StylizeRecipeTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> StylizeRecipeTarget::loadSnapshot(const EditorValue& s) {
    const auto *v = field(s, "schemaVersion"), *content = field(s, "content");
    const auto* version = v ? v->getIf<int64_t>() : nullptr;
    if (!version || *version != 1 || !content)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.stylize.snapshot"),
                                          "Unsupported stylize snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "stylize.recipe.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
 
}  // namespace eve::stylize_editing