AvatarTarget.cpp

浏览该文件的文档.

#include "avatar/editing/AvatarTarget.h"
 
#include <algorithm>
#include <cmath>
#include <set>
#include <sstream>
#include <utility>
 
namespace eve::avatar_editing {
namespace {
const EditorValue* field(const EditorValue& v, const char* k) {
    const auto* o = v.getIf<EditorValue::Object>();
    if (!o) return nullptr;
    const auto i = o->find(k);
    return i == o->end() ? nullptr : &i->second;
}
EditorValue floats(const float* v, int n) {
    EditorValue::Array a;
    for (int i = 0; i < n; ++i) a.push_back(v[i]);
    return a;
}
bool readFloats(const EditorValue* v, float* out, int n) {
    const auto* a = v ? v->getIf<EditorValue::Array>() : nullptr;
    if (!a || static_cast<int>(a->size()) != n) return false;
    for (int i = 0; i < n; ++i) {
        const auto* x = (*a)[i].getIf<double>();
        if (!x || !std::isfinite(*x)) return false;
        out[i] = static_cast<float>(*x);
    }
    return true;
}
EditorValue layerValue(const AvatarLayerValue& v) {
    return EditorValue::Object{{"id", v.id.value()},
                               {"name", v.name},
                               {"texture", v.textureAsset},
                               {"z", int64_t{v.zIndex}},
                               {"visible", v.visible},
                               {"offset", floats(v.offset.data(), 2)},
                               {"size", floats(v.size.data(), 2)},
                               {"color", floats(v.color.data(), 4)}};
}
EditorValue parameterValue(const AvatarParameterValue& v) {
    return EditorValue::Object{{"id", v.id.value()},   {"name", v.name},       {"default", v.defaultValue},
                               {"minimum", v.minimum}, {"maximum", v.maximum}, {"value", v.value}};
}
EditorValue expressionValue(const AvatarExpressionValue& v) {
    EditorValue::Object channels;
    for (const auto& [name, value] : v.channels) channels[name] = value;
    return EditorValue::Object{{"id", v.id.value()}, {"name", v.name}, {"channels", std::move(channels)}};
}
Result<AvatarLayerValue> parseLayer(const EditorValue& v) {
    AvatarLayerValue out;
    const auto *     id = field(v, "id"), *name = field(v, "name"), *texture = field(v, "texture"), *z = field(v, "z"),
               *visible  = field(v, "visible");
    const auto* ids      = id ? id->getIf<std::string>() : nullptr;
    const auto* names    = name ? name->getIf<std::string>() : nullptr;
    const auto* textures = texture ? texture->getIf<std::string>() : nullptr;
    const auto* zs       = z ? z->getIf<int64_t>() : nullptr;
    const auto* vis      = visible ? visible->getIf<bool>() : nullptr;
    if (!ids || ids->empty() || !names || !textures || !zs || !vis ||
        !readFloats(field(v, "offset"), out.offset.data(), 2) || !readFloats(field(v, "size"), out.size.data(), 2) ||
        !readFloats(field(v, "color"), out.color.data(), 4))
        return eve::editing::failed<AvatarLayerValue>(EditorStatus::Rejected, RuleId("editor.avatar.layer"),
                                                      "Avatar layer is invalid");
    out.id           = ObjectId(*ids);
    out.name         = *names;
    out.textureAsset = *textures;
    out.zIndex       = static_cast<int>(*zs);
    out.visible      = *vis;
    return eve::editing::applied<AvatarLayerValue>(std::move(out));
}
Result<AvatarParameterValue> parseParameter(const EditorValue& v) {
    AvatarParameterValue out;
    const auto *         id = field(v, "id"), *name = field(v, "name");
    const auto*          ids   = id ? id->getIf<std::string>() : nullptr;
    const auto*          names = name ? name->getIf<std::string>() : nullptr;
    if (!ids || ids->empty() || !names)
        return eve::editing::failed<AvatarParameterValue>(EditorStatus::Rejected, RuleId("editor.avatar.parameter"),
                                                          "Avatar parameter identity is invalid");
    out.id               = ObjectId(*ids);
    out.name             = *names;
    float*      values[] = {&out.defaultValue, &out.minimum, &out.maximum, &out.value};
    const char* fields[] = {"default", "minimum", "maximum", "value"};
    for (int i = 0; i < 4; ++i) {
        const auto* x = field(v, fields[i]);
        const auto* n = x ? x->getIf<double>() : nullptr;
        if (!n || !std::isfinite(*n))
            return eve::editing::failed<AvatarParameterValue>(
                EditorStatus::Rejected, RuleId("editor.avatar.parameter-number"), "Avatar parameter number is invalid");
        *values[i] = static_cast<float>(*n);
    }
    return eve::editing::applied<AvatarParameterValue>(std::move(out));
}
Result<AvatarExpressionValue> parseExpression(const EditorValue& v) {
    AvatarExpressionValue out;
    const auto *          id = field(v, "id"), *name = field(v, "name"), *channels = field(v, "channels");
    const auto*           ids    = id ? id->getIf<std::string>() : nullptr;
    const auto*           names  = name ? name->getIf<std::string>() : nullptr;
    const auto*           object = channels ? channels->getIf<EditorValue::Object>() : nullptr;
    if (!ids || ids->empty() || !names || !object)
        return eve::editing::failed<AvatarExpressionValue>(EditorStatus::Rejected, RuleId("editor.avatar.expression"),
                                                           "Avatar expression is invalid");
    out.id   = ObjectId(*ids);
    out.name = *names;
    for (const auto& [key, value] : *object) {
        const auto* n = value.getIf<double>();
        if (!n || !std::isfinite(*n))
            return eve::editing::failed<AvatarExpressionValue>(EditorStatus::Rejected,
                                                               RuleId("editor.avatar.expression-channel"),
                                                               "Avatar expression channel is invalid");
        out.channels[key] = static_cast<float>(*n);
    }
    return eve::editing::applied<AvatarExpressionValue>(std::move(out));
}
PropertyDescriptor prop(std::string path, PropertyType type, EditorValue value, const char* category, double min = -1e9,
                        double max = 1e9) {
    PropertyDescriptor d;
    d.path            = PropertyPath(path);
    d.displayNameKey  = "editor.avatar." + path;
    d.category        = category;
    d.type            = type;
    d.defaultValue    = std::move(value);
    d.flags           = PropertyFlag::Runtime;
    d.numeric.minimum = min;
    d.numeric.maximum = max;
    return d;
}
bool errors(const std::vector<EditorDiagnostic>& d) {
    return std::any_of(d.begin(), d.end(), [](const auto& v) { return v.severity() == DiagnosticSeverity::Error; });
}
EditorDiagnostic diagnostic(const char* rule, std::string message) {
    return eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument, RuleId(rule),
                                        DiagnosticSeverity::Error, std::move(message));
}
}  // namespace
AvatarDocumentTarget::AvatarDocumentTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor AvatarDocumentTarget::describe() const {
    return {TargetId(id_),
            "avatar-asset",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.avatar-properties"), IPropertyProvider::editingCapabilityId()}};
}
void* AvatarDocumentTarget::queryCapability(const CapabilityId& c) {
    if (c == CapabilityId("eve.editor.target.avatar-properties") || c == IPropertyProvider::editingCapabilityId())
        return static_cast<IPropertyProvider*>(this);
    return nullptr;
}
bool AvatarDocumentTarget::matches(const SelectionSnapshot& s) const {
    if (s.items.empty()) return false;
    const std::string type = s.items.front().type;
    for (const auto& i : s.items) {
        if (i.target != TargetId(id_) || i.type != type) return false;
        if (type == "avatar.layer" &&
            std::none_of(layers_.begin(), layers_.end(), [&](const auto& v) { return v.id.value() == i.item.value(); }))
            return false;
        if (type == "avatar.parameter" && std::none_of(parameters_.begin(), parameters_.end(),
                                                       [&](const auto& v) { return v.id.value() == i.item.value(); }))
            return false;
    }
    return type == "avatar.layer" || type == "avatar.parameter";
}
eve::Result<eve::Revision> AvatarDocumentTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "Avatar selection mismatch", "editor.avatar.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema AvatarDocumentTarget::schema(const SelectionSnapshot& s) const {
    PropertySchema schema;
    if (!s.items.empty() && s.items.front().type == "avatar.parameter") {
        schema.typeId     = "avatar.parameter";
        schema.properties = {prop("parameter.default", PropertyType::Float, 0.0, "parameter"),
                             prop("parameter.minimum", PropertyType::Float, 0.0, "parameter"),
                             prop("parameter.maximum", PropertyType::Float, 1.0, "parameter"),
                             prop("parameter.value", PropertyType::Float, 0.0, "parameter")};
    } else {
        schema.typeId     = "avatar.layer";
        schema.properties = {
            prop("layer.texture", PropertyType::AssetRef, "", "layer"),
            prop("layer.z", PropertyType::Int, int64_t{0}, "layer", -100000, 100000),
            prop("layer.visible", PropertyType::Bool, true, "layer"),
            prop("layer.offset", PropertyType::Vec2, EditorValue::Array{0.0, 0.0}, "layer"),
            prop("layer.size", PropertyType::Vec2, EditorValue::Array{64.0, 64.0}, "layer", .01, 100000),
            prop("layer.color", PropertyType::Color, EditorValue::Array{1.0, 1.0, 1.0, 1.0}, "layer", 0, 1)};
        schema.properties[0].assetTypeFilters = {"image", "texture"};
    }
    return schema;
}
PropertyReadResult AvatarDocumentTarget::read(const SelectionSnapshot& s, const PropertyPath& p) const {
    if (!matches(s) || !schema(s).find(p)) return {};
    std::optional<EditorValue> common;
    for (const auto& i : s.items) {
        EditorValue value;
        if (i.type == "avatar.layer") {
            const auto& v = *std::find_if(layers_.begin(), layers_.end(),
                                          [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("layer.texture"))
                value = v.textureAsset;
            else if (p == PropertyPath("layer.z"))
                value = int64_t{v.zIndex};
            else if (p == PropertyPath("layer.visible"))
                value = v.visible;
            else if (p == PropertyPath("layer.offset"))
                value = floats(v.offset.data(), 2);
            else if (p == PropertyPath("layer.size"))
                value = floats(v.size.data(), 2);
            else
                value = floats(v.color.data(), 4);
        } else {
            const auto& v = *std::find_if(parameters_.begin(), parameters_.end(),
                                          [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("parameter.default"))
                value = v.defaultValue;
            else if (p == PropertyPath("parameter.minimum"))
                value = v.minimum;
            else if (p == PropertyPath("parameter.maximum"))
                value = v.maximum;
            else
                value = v.value;
        }
        if (!common)
            common = value;
        else if (*common != value)
            return {PropertyReadState::Mixed, {}, {}};
    }
    return {PropertyReadState::Value, *common, {}};
}
EditorValue AvatarDocumentTarget::contentValue() const {
    EditorValue::Array layers, parameters, expressions;
    for (const auto& v : layers_) layers.push_back(layerValue(v));
    for (const auto& v : parameters_) parameters.push_back(parameterValue(v));
    for (const auto& v : expressions_) expressions.push_back(expressionValue(v));
    return EditorValue::Object{{"kind", kind_},
                               {"source", sourceAsset_},
                               {"layers", std::move(layers)},
                               {"parameters", std::move(parameters)},
                               {"expressions", std::move(expressions)}};
}
Result<DomainOperation> AvatarDocumentTarget::replacement(EditorValue content, std::string property) const {
    DomainOperation op;
    op.type        = "avatar.document.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(content);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    if (!property.empty()) op.affectedProperties.push_back(property);
    op.mergeKey = "avatar:" + id_ + ":" + (property.empty() ? "structure" : property);
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> AvatarDocumentTarget::makeSet(const SelectionSnapshot& s, const PropertyPath& p,
                                                            const EditorValue& value, PropertySetMode mode) const {
    if (mode == PropertySetMode::Reset) return makeReset(s, p);
    auto d = schema(s).find(p);
    if (!matches(s) || !d || mode != PropertySetMode::Absolute || !validatePropertyValue(*d, value).ok())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.set"),
                                                     "Avatar property edit is invalid");
    auto candidate = *this;
    for (const auto& i : s.items)
        if (i.type == "avatar.layer") {
            auto& v = *std::find_if(candidate.layers_.begin(), candidate.layers_.end(),
                                    [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("layer.texture"))
                v.textureAsset = *value.getIf<std::string>();
            else if (p == PropertyPath("layer.z"))
                v.zIndex = static_cast<int>(*value.getIf<int64_t>());
            else if (p == PropertyPath("layer.visible"))
                v.visible = *value.getIf<bool>();
            else if (p == PropertyPath("layer.offset"))
                readFloats(&value, v.offset.data(), 2);
            else if (p == PropertyPath("layer.size"))
                readFloats(&value, v.size.data(), 2);
            else
                readFloats(&value, v.color.data(), 4);
        } else {
            auto&       v = *std::find_if(candidate.parameters_.begin(), candidate.parameters_.end(),
                                          [&](const auto& x) { return x.id.value() == i.item.value(); });
            const float n = static_cast<float>(*value.getIf<double>());
            if (p == PropertyPath("parameter.default"))
                v.defaultValue = n;
            else if (p == PropertyPath("parameter.minimum"))
                v.minimum = n;
            else if (p == PropertyPath("parameter.maximum"))
                v.maximum = n;
            else
                v.value = n;
        }
    if (errors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.invalid"),
                                                     "Avatar edit produces an invalid asset");
    return replacement(candidate.contentValue(), p.value());
}
Result<DomainOperation> AvatarDocumentTarget::makeReset(const SelectionSnapshot& s, const PropertyPath& p) const {
    auto d = schema(s).find(p);
    if (!d)
        return eve::editing::failed<DomainOperation>(EditorStatus::Unsupported, RuleId("editor.avatar.property"),
                                                     "Unknown Avatar property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
Result<DomainOperation> AvatarDocumentTarget::makeSetSource(std::string kind, std::string asset) const {
    auto candidate         = *this;
    candidate.kind_        = std::move(kind);
    candidate.sourceAsset_ = std::move(asset);
    if (errors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.source"),
                                                     "Avatar source is invalid");
    return replacement(candidate.contentValue(), "source");
}
Result<DomainOperation> AvatarDocumentTarget::makeCreateLayer(const AvatarLayerValue& v) const {
    if (v.id.empty() ||
        std::any_of(layers_.begin(), layers_.end(), [&](const auto& x) { return x.id == v.id || x.name == v.name; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.layer-id"),
                                                     "Avatar layer ID and name must be unique");
    auto c = *this;
    c.layers_.push_back(v);
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.layer"),
                                                     "Avatar layer is invalid");
    return replacement(c.contentValue());
}
Result<DomainOperation> AvatarDocumentTarget::makeDeleteLayer(const ObjectId& id) const {
    if (std::none_of(layers_.begin(), layers_.end(), [&](const auto& v) { return v.id == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.avatar.layer"),
                                                     "Avatar layer does not exist");
    const auto& name = std::find_if(layers_.begin(), layers_.end(), [&](const auto& v) { return v.id == id; })->name;
    for (const auto& e : expressions_)
        if (e.channels.contains(name))
            return eve::editing::failed<DomainOperation>(EditorStatus::Conflict,
                                                         RuleId("editor.avatar.layer-reference"),
                                                         "Avatar expressions still reference this layer");
    auto c = *this;
    std::erase_if(c.layers_, [&](const auto& v) { return v.id == id; });
    return replacement(c.contentValue());
}
Result<DomainOperation> AvatarDocumentTarget::makeCreateParameter(const AvatarParameterValue& v) const {
    if (v.id.empty() || std::any_of(parameters_.begin(), parameters_.end(),
                                    [&](const auto& x) { return x.id == v.id || x.name == v.name; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.parameter-id"),
                                                     "Avatar parameter ID and name must be unique");
    auto c = *this;
    c.parameters_.push_back(v);
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.parameter"),
                                                     "Avatar parameter is invalid");
    return replacement(c.contentValue());
}
Result<DomainOperation> AvatarDocumentTarget::makeDeleteParameter(const ObjectId& id) const {
    if (std::none_of(parameters_.begin(), parameters_.end(), [&](const auto& v) { return v.id == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.avatar.parameter"),
                                                     "Avatar parameter does not exist");
    const auto& name =
        std::find_if(parameters_.begin(), parameters_.end(), [&](const auto& v) { return v.id == id; })->name;
    for (const auto& e : expressions_)
        if (e.channels.contains(name))
            return eve::editing::failed<DomainOperation>(EditorStatus::Conflict,
                                                         RuleId("editor.avatar.parameter-reference"),
                                                         "Avatar expressions still reference this parameter");
    auto c = *this;
    std::erase_if(c.parameters_, [&](const auto& v) { return v.id == id; });
    return replacement(c.contentValue());
}
Result<DomainOperation> AvatarDocumentTarget::makeCreateExpression(const AvatarExpressionValue& v) const {
    if (v.id.empty() || std::any_of(expressions_.begin(), expressions_.end(),
                                    [&](const auto& x) { return x.id == v.id || x.name == v.name; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.expression-id"),
                                                     "Avatar expression ID and name must be unique");
    auto c = *this;
    c.expressions_.push_back(v);
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.avatar.expression"),
                                                     "Avatar expression is invalid");
    return replacement(c.contentValue());
}
Result<DomainOperation> AvatarDocumentTarget::makeDeleteExpression(const ObjectId& id) const {
    if (std::none_of(expressions_.begin(), expressions_.end(), [&](const auto& v) { return v.id == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.avatar.expression"),
                                                     "Avatar expression does not exist");
    auto c = *this;
    std::erase_if(c.expressions_, [&](const auto& v) { return v.id == id; });
    return replacement(c.contentValue());
}
std::vector<EditorDiagnostic> AvatarDocumentTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    if (kind_ != "image" && kind_ != "live2d" && kind_ != "vroid")
        d.push_back(diagnostic("editor.avatar.kind", "Avatar kind must be image, live2d or vroid"));
    if (kind_ != "image" && sourceAsset_.empty())
        d.push_back(diagnostic("editor.avatar.source", "Live2D/VRoid Avatar requires a source asset"));
    if (kind_ != "image" && !layers_.empty())
        d.push_back(diagnostic("editor.avatar.backend-layers",
                               "Image layers are supported only by image Avatar assets"));
    if (layers_.size() > 512 || parameters_.size() > 2048 || expressions_.size() > 1024)
        d.push_back(diagnostic("editor.avatar.budget", "Avatar asset exceeds layer, parameter or expression budgets"));
    std::set<std::string> ids, names, channels;
    for (const auto& v : layers_) {
        if (v.id.empty() || v.name.empty() || !ids.insert(v.id.value()).second || !names.insert(v.name).second)
            d.push_back(diagnostic("editor.avatar.layer-identity", "Avatar layer IDs and names must be unique"));
        channels.insert(v.name);
        const bool vectorsFinite =
            std::all_of(v.offset.begin(), v.offset.end(), [](float n) { return std::isfinite(n); }) &&
            std::all_of(v.size.begin(), v.size.end(), [](float n) { return std::isfinite(n); });
        if (v.textureAsset.empty() || v.zIndex < -100000 || v.zIndex > 100000 || !vectorsFinite || v.size[0] <= 0 ||
            v.size[1] <= 0 ||
            !std::all_of(v.color.begin(), v.color.end(), [](float n) { return std::isfinite(n) && n >= 0 && n <= 1; }))
            d.push_back(diagnostic("editor.avatar.layer-range", "Avatar layer values are invalid"));
    }
    for (const auto& v : parameters_) {
        if (v.id.empty() || v.name.empty() || !ids.insert(v.id.value()).second || !names.insert(v.name).second)
            d.push_back(diagnostic("editor.avatar.parameter-identity",
                                   "Avatar parameter IDs and names must be unique"));
        channels.insert(v.name);
        if (!std::isfinite(v.minimum) || !std::isfinite(v.maximum) || !std::isfinite(v.defaultValue) ||
            !std::isfinite(v.value) || v.minimum > v.maximum || v.defaultValue < v.minimum ||
            v.defaultValue > v.maximum || v.value < v.minimum || v.value > v.maximum)
            d.push_back(diagnostic("editor.avatar.parameter-range", "Avatar parameter range/default/value is invalid"));
    }
    for (const auto& e : expressions_) {
        if (e.id.empty() || e.name.empty() || !ids.insert(e.id.value()).second || !names.insert(e.name).second)
            d.push_back(diagnostic("editor.avatar.expression-identity",
                                   "Avatar expression IDs and names must be unique"));
        if (e.channels.size() > 2048)
            d.push_back(diagnostic("editor.avatar.expression-budget", "Avatar expression exceeds 2048 channels"));
        for (const auto& [name, value] : e.channels)
            if (!channels.contains(name) || !std::isfinite(value))
                d.push_back(diagnostic("editor.avatar.expression-channel",
                                       "Avatar expression references an unknown or invalid channel"));
    }
    return d;
}
Result<void> AvatarDocumentTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "avatar.document.replace.v1" ||
        !op.payload.isWithinLimits(8, 100000, 8 * 1024 * 1024))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.operation"),
                                          "Avatar operation is invalid");
    const auto *kind = field(op.payload, "kind"), *source = field(op.payload, "source"),
               *layers = field(op.payload, "layers"), *parameters = field(op.payload, "parameters"),
               *expressions = field(op.payload, "expressions");
    const auto* k           = kind ? kind->getIf<std::string>() : nullptr;
    const auto* s           = source ? source->getIf<std::string>() : nullptr;
    const auto* la          = layers ? layers->getIf<EditorValue::Array>() : nullptr;
    const auto* pa          = parameters ? parameters->getIf<EditorValue::Array>() : nullptr;
    const auto* ea          = expressions ? expressions->getIf<EditorValue::Array>() : nullptr;
    if (!k || !s || !la || !pa || !ea || la->size() > 512 || pa->size() > 2048 || ea->size() > 1024)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.payload"),
                                          "Avatar payload is invalid or exceeds budgets");
    AvatarDocumentTarget c(id_);
    c.kind_        = *k;
    c.sourceAsset_ = *s;
    for (const auto& v : *la) {
        auto parsed = parseLayer(v);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.layer"),
                                              "Avatar layer cannot be parsed");
        c.layers_.push_back(std::move(parsed.value()));
    }
    for (const auto& v : *pa) {
        auto parsed = parseParameter(v);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.parameter"),
                                              "Avatar parameter cannot be parsed");
        c.parameters_.push_back(std::move(parsed.value()));
    }
    for (const auto& v : *ea) {
        auto parsed = parseExpression(v);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.expression"),
                                              "Avatar expression cannot be parsed");
        c.expressions_.push_back(std::move(parsed.value()));
    }
    if (errors(c.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.avatar.invalid"),
                                          "Avatar document validation failed");
    kind_        = std::move(c.kind_);
    sourceAsset_ = std::move(c.sourceAsset_);
    layers_      = std::move(c.layers_);
    parameters_  = std::move(c.parameters_);
    expressions_ = std::move(c.expressions_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> AvatarDocumentTarget::cloneDomainState() const {
    return std::make_unique<AvatarDocumentTarget>(*this);
}
Result<void> AvatarDocumentTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> c) {
    auto* t = dynamic_cast<AvatarDocumentTarget*>(c.get());
    if (!t || t->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.avatar.candidate"),
                                          "Avatar candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
EditorValue AvatarDocumentTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> AvatarDocumentTarget::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.avatar.snapshot"),
                                          "Unsupported Avatar snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "avatar.document.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
}  // namespace eve::avatar_editing