SpriteStackTarget.cpp

浏览该文件的文档.

#include "spritestack/editing/SpriteStackTarget.h"
 
#include <algorithm>
#include <cmath>
#include <utility>
 
namespace eve::spritestack_editing {
namespace {
const EditorValue* field(const EditorValue& value, const char* key) {
    const auto* object = value.getIf<EditorValue::Object>();
    if (!object) return nullptr;
    const auto it = object->find(key);
    return it == object->end() ? nullptr : &it->second;
}
PropertyDescriptor prop(std::string path, PropertyType type, EditorValue value, const char* category,
                        double minimum = -1e9, double maximum = 1e9) {
    PropertyDescriptor d;
    d.path            = PropertyPath(path);
    d.displayNameKey  = "editor.spritestack." + path;
    d.category        = category;
    d.type            = type;
    d.defaultValue    = std::move(value);
    d.flags           = PropertyFlag::EditorOnly;
    d.numeric.minimum = minimum;
    d.numeric.maximum = maximum;
    return d;
}
bool errors(const std::vector<EditorDiagnostic>& values) {
    return std::any_of(values.begin(), values.end(),
                       [](const auto& d) { return d.severity() == DiagnosticSeverity::Error; });
}
}  // namespace
 
SpriteStackDocumentTarget::SpriteStackDocumentTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor SpriteStackDocumentTarget::describe() const {
    return {TargetId(id_),
            "spritestack-asset",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.spritestack-properties")}};
}
void* SpriteStackDocumentTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.spritestack-properties") ? static_cast<IPropertyProvider*>(this)
                                                                         : nullptr;
}
bool SpriteStackDocumentTarget::matches(const SelectionSnapshot& s) const {
    return s.items.size() == 1 && s.items.front().target == TargetId(id_) && s.items.front().item.value() == id_;
}
eve::Result<eve::Revision> SpriteStackDocumentTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "SpriteStack selection mismatch", "editor.spritestack.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema SpriteStackDocumentTarget::schema(const SelectionSnapshot&) const {
    PropertySchema s;
    s.typeId     = "spritestack.asset";
    s.properties = {prop("source.kind", PropertyType::Enum, "primitive", "source"),
                    prop("source.value", PropertyType::AssetRef, "box", "source"),
                    prop("bake.layers", PropertyType::Int, int64_t{16}, "bake", 1, 512),
                    prop("bake.width", PropertyType::Int, int64_t{128}, "bake", 1, 4096),
                    prop("bake.height", PropertyType::Int, int64_t{128}, "bake", 1, 4096),
                    prop("bake.axis", PropertyType::Enum, "y", "bake"),
                    prop("bake.thickness", PropertyType::Float, 0.0, "bake", 0, 100000),
                    prop("bake.padding", PropertyType::Float, .04, "bake", 0, .49),
                    prop("bake.shade", PropertyType::Bool, true, "bake"),
                    prop("bake.tint", PropertyType::Color, EditorValue::Array{1.0, 1.0, 1.0, 1.0}, "bake", 0, 1),
                    prop("display.size", PropertyType::Vec2, EditorValue::Array{64.0, 64.0}, "display", .01, 100000),
                    prop("display.layerOffset", PropertyType::Float, 1.0, "display", .001, 100000),
                    prop("display.shadow", PropertyType::Bool, true, "display"),
                    prop("display.shadowOpacity", PropertyType::Float, .3, "display", 0, 1),
                    prop("display.outlineWidth", PropertyType::Float, 0.0, "display", 0, 10000)};
    s.properties[0].enumItems        = {"primitive", "model"};
    s.properties[1].assetTypeFilters = {"model3d"};
    s.properties[5].enumItems        = {"x", "y", "z"};
    return s;
}
EditorValue SpriteStackDocumentTarget::contentValue() const {
    const auto& v = value_;
    return EditorValue::Object{{"sourceKind", v.sourceKind},
                               {"source", v.source},
                               {"layers", int64_t{v.bake.layerCount}},
                               {"width", int64_t{v.bake.imageW}},
                               {"height", int64_t{v.bake.imageH}},
                               {"axis", v.bake.axis},
                               {"thickness", v.bake.thickness},
                               {"padding", v.bake.padding},
                               {"shade", v.bake.shade},
                               {"tint", EditorValue::Array{v.bake.tintR, v.bake.tintG, v.bake.tintB, 1.0}},
                               {"displaySize", EditorValue::Array{v.displayWidth, v.displayHeight}},
                               {"layerOffset", v.layerOffset},
                               {"shadow", v.shadow},
                               {"shadowOpacity", v.shadowOpacity},
                               {"outlineWidth", v.outlineWidth}};
}
PropertyReadResult SpriteStackDocumentTarget::read(const SelectionSnapshot& s, const PropertyPath& p) const {
    if (!matches(s) || !schema(s).find(p)) return {};
    const auto& v = value_;
    EditorValue value;
    if (p == PropertyPath("source.kind"))
        value = v.sourceKind;
    else if (p == PropertyPath("source.value"))
        value = v.source;
    else if (p == PropertyPath("bake.layers"))
        value = int64_t{v.bake.layerCount};
    else if (p == PropertyPath("bake.width"))
        value = int64_t{v.bake.imageW};
    else if (p == PropertyPath("bake.height"))
        value = int64_t{v.bake.imageH};
    else if (p == PropertyPath("bake.axis"))
        value = v.bake.axis;
    else if (p == PropertyPath("bake.thickness"))
        value = v.bake.thickness;
    else if (p == PropertyPath("bake.padding"))
        value = v.bake.padding;
    else if (p == PropertyPath("bake.shade"))
        value = v.bake.shade;
    else if (p == PropertyPath("bake.tint"))
        value = EditorValue::Array{v.bake.tintR, v.bake.tintG, v.bake.tintB, 1.0};
    else if (p == PropertyPath("display.size"))
        value = EditorValue::Array{v.displayWidth, v.displayHeight};
    else if (p == PropertyPath("display.layerOffset"))
        value = v.layerOffset;
    else if (p == PropertyPath("display.shadow"))
        value = v.shadow;
    else if (p == PropertyPath("display.shadowOpacity"))
        value = v.shadowOpacity;
    else
        value = v.outlineWidth;
    return {PropertyReadState::Value, std::move(value), {}};
}
Result<DomainOperation> SpriteStackDocumentTarget::replacement(EditorValue content,
                                                                      std::string property) const {
    DomainOperation op;
    op.type        = "spritestack.document.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(content);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    op.affectedProperties.push_back(property);
    op.mergeKey = "spritestack:" + id_ + ":" + property;
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> SpriteStackDocumentTarget::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.spritestack.set"),
                                                     "SpriteStack property edit is invalid");
    auto  candidate = *this;
    auto& v         = candidate.value_;
    if (p == PropertyPath("source.kind"))
        v.sourceKind = *value.getIf<std::string>();
    else if (p == PropertyPath("source.value"))
        v.source = *value.getIf<std::string>();
    else if (p == PropertyPath("bake.layers"))
        v.bake.layerCount = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("bake.width"))
        v.bake.imageW = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("bake.height"))
        v.bake.imageH = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("bake.axis"))
        v.bake.axis = *value.getIf<std::string>();
    else if (p == PropertyPath("bake.thickness"))
        v.bake.thickness = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("bake.padding"))
        v.bake.padding = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("bake.shade"))
        v.bake.shade = *value.getIf<bool>();
    else if (p == PropertyPath("bake.tint")) {
        const auto& a = *value.getIf<EditorValue::Array>();
        v.bake.tintR  = static_cast<float>(*a[0].getIf<double>());
        v.bake.tintG  = static_cast<float>(*a[1].getIf<double>());
        v.bake.tintB  = static_cast<float>(*a[2].getIf<double>());
    } else if (p == PropertyPath("display.size")) {
        const auto& a   = *value.getIf<EditorValue::Array>();
        v.displayWidth  = static_cast<float>(*a[0].getIf<double>());
        v.displayHeight = static_cast<float>(*a[1].getIf<double>());
    } else if (p == PropertyPath("display.layerOffset"))
        v.layerOffset = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("display.shadow"))
        v.shadow = *value.getIf<bool>();
    else if (p == PropertyPath("display.shadowOpacity"))
        v.shadowOpacity = static_cast<float>(*value.getIf<double>());
    else
        v.outlineWidth = static_cast<float>(*value.getIf<double>());
    if (errors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.spritestack.invalid"),
                                                     "SpriteStack edit violates bake budgets");
    return replacement(candidate.contentValue(), p.value());
}
Result<DomainOperation> SpriteStackDocumentTarget::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.spritestack.property"),
                                                     "Unknown SpriteStack property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
std::vector<EditorDiagnostic> SpriteStackDocumentTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    const auto&                   v = value_;
    if (v.sourceKind != "primitive" && v.sourceKind != "model")
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
                     RuleId("editor.spritestack.source-kind"), DiagnosticSeverity::Error,
                     "SpriteStack source kind must be primitive or model"));
    if (v.source.empty())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.spritestack.source"), DiagnosticSeverity::Error, "SpriteStack source must not be empty"));
    if (v.sourceKind == "primitive" && v.source != "box" && v.source != "sphere" && v.source != "cylinder" &&
        v.source != "cone")
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.spritestack.primitive"), DiagnosticSeverity::Error, "Unknown SpriteStack primitive"));
    const bool axisInvalid = v.bake.axis != "x" && v.bake.axis != "y" && v.bake.axis != "z";
    if (v.bake.layerCount < 1 || v.bake.layerCount > 512 || v.bake.imageW < 1 || v.bake.imageW > 4096 ||
        v.bake.imageH < 1 || v.bake.imageH > 4096 || axisInvalid || !std::isfinite(v.bake.thickness) ||
        v.bake.thickness < 0 || !std::isfinite(v.bake.padding) || v.bake.padding < 0 || v.bake.padding >= .5f)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.spritestack.bake-range"), DiagnosticSeverity::Error,
            "SpriteStack bake settings are invalid"));
    const std::uint64_t bytes = static_cast<std::uint64_t>(std::max(0, v.bake.layerCount)) *
                                std::max(0, v.bake.imageW) * std::max(0, v.bake.imageH) * 4ull;
    if (bytes > 512ull * 1024 * 1024)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.spritestack.memory"), DiagnosticSeverity::Error,
            "SpriteStack output exceeds the 512 MiB decoded budget"));
    else if (bytes > 128ull * 1024 * 1024)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.spritestack.memory-warning"), DiagnosticSeverity::Warning,
            "SpriteStack output exceeds 128 MiB decoded"));
    if (!std::isfinite(v.displayWidth) || v.displayWidth <= 0 || !std::isfinite(v.displayHeight) ||
        v.displayHeight <= 0 || !std::isfinite(v.layerOffset) || v.layerOffset <= 0 ||
        !std::isfinite(v.shadowOpacity) || v.shadowOpacity < 0 || v.shadowOpacity > 1 ||
        !std::isfinite(v.outlineWidth) || v.outlineWidth < 0)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.spritestack.display"), DiagnosticSeverity::Error,
            "SpriteStack presentation values are invalid"));
    return d;
}
Result<void> SpriteStackDocumentTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "spritestack.document.replace.v1" ||
        !op.payload.isWithinLimits(5, 64, 4096))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.operation"),
                                          "SpriteStack operation is invalid");
    SpriteStackAssetValue v;
    const auto *          sKind = field(op.payload, "sourceKind"), *source = field(op.payload, "source"),
               *axis = field(op.payload, "axis"), *shade = field(op.payload, "shade"),
               *shadow = field(op.payload, "shadow");
    const auto* sk     = sKind ? sKind->getIf<std::string>() : nullptr;
    const auto* sv     = source ? source->getIf<std::string>() : nullptr;
    const auto* av     = axis ? axis->getIf<std::string>() : nullptr;
    const auto* sh     = shade ? shade->getIf<bool>() : nullptr;
    const auto* sd     = shadow ? shadow->getIf<bool>() : nullptr;
    if (!sk || !sv || !av || !sh || !sd)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.payload"),
                                          "SpriteStack text or bool field is invalid");
    v.sourceKind            = *sk;
    v.source                = *sv;
    v.bake.axis             = *av;
    v.bake.shade            = *sh;
    v.shadow                = *sd;
    int*        ints[]      = {&v.bake.layerCount, &v.bake.imageW, &v.bake.imageH};
    const char* intFields[] = {"layers", "width", "height"};
    for (int i = 0; i < 3; ++i) {
        const auto* x = field(op.payload, intFields[i]);
        const auto* n = x ? x->getIf<int64_t>() : nullptr;
        if (!n)
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.integer"),
                                              "SpriteStack integer is invalid");
        *ints[i] = static_cast<int>(*n);
    }
    float*      floats[]      = {&v.bake.thickness, &v.bake.padding, &v.layerOffset, &v.shadowOpacity, &v.outlineWidth};
    const char* floatFields[] = {"thickness", "padding", "layerOffset", "shadowOpacity", "outlineWidth"};
    for (int i = 0; i < 5; ++i) {
        const auto* x = field(op.payload, floatFields[i]);
        const auto* n = x ? x->getIf<double>() : nullptr;
        if (!n || !std::isfinite(*n))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.number"),
                                              "SpriteStack number is invalid");
        *floats[i] = static_cast<float>(*n);
    }
    const auto *tintValue = field(op.payload, "tint"), *sizeValue = field(op.payload, "displaySize");
    const auto* tint = tintValue ? tintValue->getIf<EditorValue::Array>() : nullptr;
    const auto* size = sizeValue ? sizeValue->getIf<EditorValue::Array>() : nullptr;
    if (!tint || tint->size() != 4 || !size || size->size() != 2)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.vector"),
                                          "SpriteStack vector is invalid");
    float* tints[] = {&v.bake.tintR, &v.bake.tintG, &v.bake.tintB};
    for (int i = 0; i < 3; ++i) {
        const auto* n = (*tint)[i].getIf<double>();
        if (!n || !std::isfinite(*n))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.tint"),
                                              "SpriteStack tint is invalid");
        *tints[i] = static_cast<float>(*n);
    }
    const auto *w = (*size)[0].getIf<double>(), *h = (*size)[1].getIf<double>();
    if (!w || !h)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.size"),
                                          "SpriteStack display size is invalid");
    v.displayWidth  = static_cast<float>(*w);
    v.displayHeight = static_cast<float>(*h);
    SpriteStackDocumentTarget candidate(id_);
    candidate.value_ = v;
    if (errors(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.spritestack.invalid"),
                                          "SpriteStack document validation failed");
    value_ = std::move(v);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> SpriteStackDocumentTarget::cloneDomainState() const {
    return std::make_unique<SpriteStackDocumentTarget>(*this);
}
Result<void> SpriteStackDocumentTarget::commitDomainState(
    std::unique_ptr<IDomainOperationTarget> candidate) {
    auto* typed = dynamic_cast<SpriteStackDocumentTarget*>(candidate.get());
    if (!typed || typed->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.spritestack.candidate"),
                                          "SpriteStack candidate mismatch");
    *this = *typed;
    return eve::editing::applied<void>();
}
EditorValue SpriteStackDocumentTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> SpriteStackDocumentTarget::loadSnapshot(const EditorValue& snapshot) {
    const auto *v = field(snapshot, "schemaVersion"), *content = field(snapshot, "content");
    const auto* version = v ? v->getIf<int64_t>() : nullptr;
    if (!version || *version != 1 || !content)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.spritestack.snapshot"),
                                          "Unsupported SpriteStack snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "spritestack.document.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
 
}  // namespace eve::spritestack_editing