VoxelPaletteTarget.cpp

浏览该文件的文档.

#include "voxel/editing/VoxelPaletteTarget.h"
 
#include <algorithm>
#include <set>
#include <utility>
 
namespace eve::voxel_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 faces(const std::uint8_t* v) {
    EditorValue::Array a;
    for (int i = 0; i < 6; ++i) a.push_back(int64_t{v[i]});
    return a;
}
EditorValue entryValue(const VoxelPaletteEntryValue& v) {
    return EditorValue::Object{{"id", v.id.value()},
                               {"name", v.type.name},
                               {"faces", faces(v.type.faceTex)},
                               {"directional", v.type.directional},
                               {"composeGroup", v.type.composeGroup},
                               {"connects", v.type.connects}};
}
Result<VoxelPaletteEntryValue> parse(const EditorValue& v) {
    VoxelPaletteEntryValue out;
    const auto *           id = field(v, "id"), *name = field(v, "name"), *directional = field(v, "directional"),
               *group = field(v, "composeGroup"), *connects = field(v, "connects"), *faceValue = field(v, "faces");
    const auto* ids    = id ? id->getIf<std::string>() : nullptr;
    const auto* names  = name ? name->getIf<std::string>() : nullptr;
    const auto* dirs   = directional ? directional->getIf<bool>() : nullptr;
    const auto* groups = group ? group->getIf<std::string>() : nullptr;
    const auto* conns  = connects ? connects->getIf<bool>() : nullptr;
    const auto* fa     = faceValue ? faceValue->getIf<EditorValue::Array>() : nullptr;
    if (!ids || ids->empty() || !names || !dirs || !groups || !conns || !fa || fa->size() != 6)
        return eve::editing::failed<VoxelPaletteEntryValue>(
            EditorStatus::Rejected, RuleId("editor.voxel-palette.entry"), "Voxel palette entry is invalid");
    out.id                = ObjectId(*ids);
    out.type.name         = *names;
    out.type.directional  = *dirs;
    out.type.composeGroup = *groups;
    out.type.connects     = *conns;
    for (int i = 0; i < 6; ++i) {
        const auto* n = (*fa)[i].getIf<int64_t>();
        if (!n || *n < 0 || *n > 255)
            return eve::editing::failed<VoxelPaletteEntryValue>(
                EditorStatus::Rejected, RuleId("editor.voxel-palette.face"), "Voxel face texture must be 0..255");
        out.type.faceTex[i] = static_cast<std::uint8_t>(*n);
    }
    return eve::editing::applied<VoxelPaletteEntryValue>(std::move(out));
}
PropertyDescriptor prop(std::string path, PropertyType type, EditorValue value) {
    PropertyDescriptor d;
    d.path           = PropertyPath(path);
    d.displayNameKey = "editor.voxel-palette." + path;
    d.category       = "cube-type";
    d.type           = type;
    d.defaultValue   = std::move(value);
    d.flags          = PropertyFlag::Runtime;
    if (type == PropertyType::Array) d.presenterHint = "face-texture-six";
    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; });
}
}  // namespace
VoxelPaletteTarget::VoxelPaletteTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor VoxelPaletteTarget::describe() const {
    return {TargetId(id_),
            "voxel-palette",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.voxel-palette-properties")}};
}
void* VoxelPaletteTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.voxel-palette-properties") ? static_cast<IPropertyProvider*>(this)
                                                                           : nullptr;
}
bool VoxelPaletteTarget::matches(const SelectionSnapshot& s) const {
    if (s.items.empty()) return false;
    for (const auto& i : s.items)
        if (i.target != TargetId(id_) || std::none_of(entries_.begin(), entries_.end(),
                                                      [&](const auto& v) { return v.id.value() == i.item.value(); }))
            return false;
    return true;
}
eve::Result<eve::Revision> VoxelPaletteTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,
                                                                          "Voxel palette selection mismatch",
                                                                          "editor.voxel-palette.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema VoxelPaletteTarget::schema(const SelectionSnapshot&) const {
    PropertySchema s;
    s.typeId     = "voxel.cube-type";
    s.properties = {prop("cube.faces", PropertyType::Array,
                         EditorValue::Array{int64_t{0}, int64_t{0}, int64_t{0}, int64_t{0}, int64_t{0}, int64_t{0}}),
                    prop("cube.directional", PropertyType::Bool, false),
                    prop("cube.composeGroup", PropertyType::String, ""),
                    prop("cube.connects", PropertyType::Bool, false)};
    return s;
}
PropertyReadResult VoxelPaletteTarget::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) {
        const auto& v = std::find_if(entries_.begin(), entries_.end(), [&](const auto& x) {
                            return x.id.value() == i.item.value();
                        })->type;
        EditorValue value;
        if (p == PropertyPath("cube.faces"))
            value = faces(v.faceTex);
        else if (p == PropertyPath("cube.directional"))
            value = v.directional;
        else if (p == PropertyPath("cube.composeGroup"))
            value = v.composeGroup;
        else
            value = v.connects;
        if (!common)
            common = value;
        else if (*common != value)
            return {PropertyReadState::Mixed, {}, {}};
    }
    return {PropertyReadState::Value, *common, {}};
}
EditorValue VoxelPaletteTarget::contentValue() const {
    EditorValue::Array a;
    for (const auto& v : entries_) a.push_back(entryValue(v));
    return EditorValue::Object{{"entries", std::move(a)}};
}
Result<DomainOperation> VoxelPaletteTarget::replacement(EditorValue content,
                                                               std::string property) const {
    DomainOperation op;
    op.type        = "voxel.palette.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 = "voxel-palette:" + id_ + ":" + (property.empty() ? "structure" : property);
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> VoxelPaletteTarget::makeSet(const SelectionSnapshot& s, const PropertyPath& p,
                                                          const EditorValue& value, PropertySetMode mode) const {
    if (mode == PropertySetMode::Reset) return makeReset(s, p);
    if (!matches(s) || !schema(s).find(p) || mode != PropertySetMode::Absolute)
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.voxel-palette.set"),
                                                     "Voxel palette property edit is invalid");
    auto c = *this;
    for (const auto& i : s.items) {
        auto& v = std::find_if(c.entries_.begin(), c.entries_.end(), [&](const auto& x) {
                      return x.id.value() == i.item.value();
                  })->type;
        if (p == PropertyPath("cube.faces")) {
            const auto* a = value.getIf<EditorValue::Array>();
            if (!a || a->size() != 6)
                return eve::editing::failed<DomainOperation>(EditorStatus::Rejected,
                                                             RuleId("editor.voxel-palette.faces"),
                                                             "Voxel faces require six texture IDs");
            for (int face = 0; face < 6; ++face) {
                const auto* n = (*a)[face].getIf<int64_t>();
                if (!n || *n < 0 || *n > 255)
                    return eve::editing::failed<DomainOperation>(
                        EditorStatus::Rejected, RuleId("editor.voxel-palette.face"), "Voxel texture ID must be 0..255");
                v.faceTex[face] = static_cast<std::uint8_t>(*n);
            }
        } else if (p == PropertyPath("cube.directional"))
            v.directional = *value.getIf<bool>();
        else if (p == PropertyPath("cube.composeGroup"))
            v.composeGroup = *value.getIf<std::string>();
        else
            v.connects = *value.getIf<bool>();
    }
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.voxel-palette.capacity"),
                                                     "Voxel palette edit exceeds the 255 variant capacity");
    return replacement(c.contentValue(), p.value());
}
Result<DomainOperation> VoxelPaletteTarget::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.voxel-palette.property"),
                                                     "Unknown Voxel palette property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
Result<DomainOperation> VoxelPaletteTarget::makeCreate(const VoxelPaletteEntryValue& v) const {
    if (v.id.empty() || v.type.name.empty() || std::any_of(entries_.begin(), entries_.end(), [&](const auto& x) {
            return x.id == v.id || x.type.name == v.type.name;
        }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.voxel-palette.identity"),
                                                     "Voxel palette ID and name must be unique");
    auto c = *this;
    c.entries_.push_back(v);
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.voxel-palette.capacity"),
                                                     "Voxel palette exceeds the 255 variant capacity");
    return replacement(c.contentValue());
}
Result<DomainOperation> VoxelPaletteTarget::makeDelete(const ObjectId& id) const {
    if (std::none_of(entries_.begin(), entries_.end(), [&](const auto& v) { return v.id == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.voxel-palette.entry"),
                                                     "Voxel palette entry does not exist");
    auto c = *this;
    std::erase_if(c.entries_, [&](const auto& v) { return v.id == id; });
    return replacement(c.contentValue());
}
std::vector<EditorDiagnostic> VoxelPaletteTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    std::set<std::string>         ids, names;
    int                           variants = 0;
    for (const auto& v : entries_) {
        variants += v.type.directional ? 4 : 1;
        if (v.id.empty() || v.type.name.empty() || !ids.insert(v.id.value()).second ||
            !names.insert(v.type.name).second)
            d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::Conflict,
                RuleId("editor.voxel-palette.identity"), DiagnosticSeverity::Error,
                "Voxel palette IDs and names must be non-empty and unique"));
        if (v.type.connects && v.type.composeGroup.empty())
            d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
                RuleId("editor.voxel-palette.connect-group"), DiagnosticSeverity::Warning,
                "Connecting cube type has no compose group"));
    }
    if (variants > 255)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.voxel-palette.variant-capacity"), DiagnosticSeverity::Error,
            "Voxel palette exceeds 255 runtime variants"));
    if (entries_.empty())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.voxel-palette.empty"), DiagnosticSeverity::Warning, "Voxel palette has no cube types"));
    return d;
}
Result<void> VoxelPaletteTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "voxel.palette.replace.v1")
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.voxel-palette.operation"),
                                          "Voxel palette operation mismatch");
    const auto* values = field(op.payload, "entries");
    const auto* a      = values ? values->getIf<EditorValue::Array>() : nullptr;
    if (!a || a->size() > 255 || !op.payload.isWithinLimits(6, 10000, 1024 * 1024))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.voxel-palette.payload"),
                                          "Voxel palette payload exceeds limits");
    VoxelPaletteTarget c(id_);
    for (const auto& v : *a) {
        auto parsed = parse(v);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.voxel-palette.entry"),
                                              "Voxel palette entry cannot be parsed");
        c.entries_.push_back(parsed.value());
    }
    if (errors(c.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.voxel-palette.invalid"),
                                          "Voxel palette validation failed");
    entries_ = std::move(c.entries_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> VoxelPaletteTarget::cloneDomainState() const {
    return std::make_unique<VoxelPaletteTarget>(*this);
}
Result<void> VoxelPaletteTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> c) {
    auto* t = dynamic_cast<VoxelPaletteTarget*>(c.get());
    if (!t || t->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.voxel-palette.candidate"),
                                          "Voxel palette candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
EditorValue VoxelPaletteTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> VoxelPaletteTarget::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.voxel-palette.snapshot"),
                                          "Unsupported Voxel palette snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "voxel.palette.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
}  // namespace eve::voxel_editing