InputMapTarget.cpp

浏览该文件的文档.

#include "editor/input/editing/InputMapTarget.h"
#include <algorithm>
#include <cmath>
#include <set>
#include <utility>
namespace eve::input_editing {
using namespace eve::editing;
namespace {
const EditorValue* field(const EditorValue& v, const char* k) {
    auto* o = v.getIf<EditorValue::Object>();
    if (!o) return nullptr;
    auto i = o->find(k);
    return i == o->end() ? nullptr : &i->second;
}
EditorValue action(const InputActionValue& v) {
    return EditorValue::Object{{"id", v.id.value()}, {"name", v.name}, {"kind", v.kind}};
}
EditorValue binding(const InputBindingValue& v) {
    return EditorValue::Object{{"id", v.id.value()},   {"action", v.action.value()}, {"device", v.device},
                               {"control", v.control}, {"scale", v.scale},           {"deadzone", v.deadzone},
                               {"invert", v.invert}};
}
PropertyDescriptor prop(std::string p, PropertyType t, EditorValue d, const char* c, double lo = -1e9,
                        double hi = 1e9) {
    PropertyDescriptor x;
    x.path            = PropertyPath(p);
    x.displayNameKey  = "editor.input." + p;
    x.category        = c;
    x.type            = t;
    x.defaultValue    = std::move(d);
    x.flags           = PropertyFlag::Runtime;
    x.numeric.minimum = lo;
    x.numeric.maximum = hi;
    return x;
}
bool errors(const std::vector<EditorDiagnostic>& d) {
    return std::any_of(d.begin(), d.end(),
                       [](const auto& x) { return x.severity() == DiagnosticSeverity::Error; });
}
}  // namespace
InputMapTarget::InputMapTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor InputMapTarget::describe() const {
    return {TargetId(id_), "input-map", revision_, false, {CapabilityId("eve.editor.target.input-map-properties")}};
}
void* InputMapTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.input-map-properties") ? static_cast<IPropertyProvider*>(this)
                                                                       : nullptr;
}
bool InputMapTarget::matches(const SelectionSnapshot& s) const {
    if (s.items.empty()) return false;
    const auto type = s.items[0].type;
    for (const auto& i : s.items) {
        if (i.target != TargetId(id_) || i.type != type) return false;
        bool found = type == "input.action" ? std::any_of(actions_.begin(), actions_.end(),
                                                          [&](const auto& v) { return v.id.value() == i.item.value(); })
                                            : std::any_of(bindings_.begin(), bindings_.end(), [&](const auto& v) {
                                                  return v.id.value() == i.item.value();
                                              });
        if (!found) return false;
    }
    return type == "input.action" || type == "input.binding";
}
eve::Result<eve::Revision> InputMapTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "Input selection mismatch", "editor.input.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revision_));
}
PropertySchema InputMapTarget::schema(const SelectionSnapshot& s) const {
    PropertySchema x;
    if (!s.items.empty() && s.items[0].type == "input.binding") {
        x.typeId                  = "input.binding";
        x.properties              = {prop("binding.action", PropertyType::ObjectRef, "", "binding"),
                                     prop("binding.device", PropertyType::Enum, "keyboard", "binding"),
                                     prop("binding.control", PropertyType::String, "", "binding"),
                                     prop("binding.scale", PropertyType::Float, 1.0, "response", -100, 100),
                                     prop("binding.deadzone", PropertyType::Float, 0.0, "response", 0, .99),
                                     prop("binding.invert", PropertyType::Bool, false, "response")};
        x.properties[1].enumItems = {"keyboard", "mouse", "gamepad", "joystick", "touch"};
    } else {
        x.typeId                  = "input.action";
        x.properties              = {prop("action.name", PropertyType::String, "", "action"),
                                     prop("action.kind", PropertyType::Enum, "button", "action")};
        x.properties[1].enumItems = {"button", "axis1d"};
    }
    return x;
}
PropertyReadResult InputMapTarget::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 v;
        if (i.type == "input.action") {
            const auto& a = *std::find_if(actions_.begin(), actions_.end(),
                                          [&](const auto& x) { return x.id.value() == i.item.value(); });
            v             = p == PropertyPath("action.name") ? EditorValue(a.name) : EditorValue(a.kind);
        } else {
            const auto& b = *std::find_if(bindings_.begin(), bindings_.end(),
                                          [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("binding.action"))
                v = b.action.value();
            else if (p == PropertyPath("binding.device"))
                v = b.device;
            else if (p == PropertyPath("binding.control"))
                v = b.control;
            else if (p == PropertyPath("binding.scale"))
                v = b.scale;
            else if (p == PropertyPath("binding.deadzone"))
                v = b.deadzone;
            else
                v = b.invert;
        }
        if (!common)
            common = v;
        else if (*common != v)
            return {PropertyReadState::Mixed, {}, {}};
    }
    return {PropertyReadState::Value, *common, {}};
}
EditorValue InputMapTarget::contentValue() const {
    EditorValue::Array a, b;
    for (const auto& v : actions_) a.push_back(action(v));
    for (const auto& v : bindings_) b.push_back(binding(v));
    return EditorValue::Object{{"actions", std::move(a)}, {"bindings", std::move(b)}};
}
Result<DomainOperation> InputMapTarget::replacement(EditorValue v, std::string p) const {
    DomainOperation op;
    op.type        = "input-map.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(v);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    if (!p.empty()) op.affectedProperties.push_back(p);
    op.mergeKey = "input-map:" + id_ + ":" + (p.empty() ? "structure" : p);
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> InputMapTarget::makeSet(const SelectionSnapshot& s, const PropertyPath& p,
                                                      const EditorValue& v, 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, v).ok())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.input.set"),
                                                     "Input property edit is invalid");
    auto c = *this;
    for (const auto& i : s.items)
        if (i.type == "input.action") {
            auto& a = *std::find_if(c.actions_.begin(), c.actions_.end(),
                                    [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("action.name"))
                a.name = *v.getIf<std::string>();
            else
                a.kind = *v.getIf<std::string>();
        } else {
            auto& b = *std::find_if(c.bindings_.begin(), c.bindings_.end(),
                                    [&](const auto& x) { return x.id.value() == i.item.value(); });
            if (p == PropertyPath("binding.action"))
                b.action = ObjectId(*v.getIf<std::string>());
            else if (p == PropertyPath("binding.device"))
                b.device = *v.getIf<std::string>();
            else if (p == PropertyPath("binding.control"))
                b.control = *v.getIf<std::string>();
            else if (p == PropertyPath("binding.scale"))
                b.scale = *v.getIf<double>();
            else if (p == PropertyPath("binding.deadzone"))
                b.deadzone = *v.getIf<double>();
            else
                b.invert = *v.getIf<bool>();
        }
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.input.invalid"),
                                                     "Input edit produces invalid bindings");
    return replacement(c.contentValue(), p.value());
}
Result<DomainOperation> InputMapTarget::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.input.property"),
                                                     "Unknown input property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
Result<DomainOperation> InputMapTarget::makeCreateAction(InputActionValue v) const {
    auto c = *this;
    c.actions_.push_back(std::move(v));
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.input.action"),
                                                     "Input action is invalid");
    return replacement(c.contentValue());
}
Result<DomainOperation> InputMapTarget::makeDeleteAction(const ObjectId& id) const {
    if (std::any_of(bindings_.begin(), bindings_.end(), [&](const auto& b) { return b.action == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.input.action-referenced"),
                                                     "Delete bindings before deleting their action");
    auto       c      = *this;
    const auto before = c.actions_.size();
    std::erase_if(c.actions_, [&](const auto& a) { return a.id == id; });
    if (before == c.actions_.size())
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.input.action"),
                                                     "Input action does not exist");
    return replacement(c.contentValue());
}
Result<DomainOperation> InputMapTarget::makeCreateBinding(InputBindingValue v) const {
    auto c = *this;
    c.bindings_.push_back(std::move(v));
    if (errors(c.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.input.binding"),
                                                     "Input binding is invalid");
    return replacement(c.contentValue());
}
Result<DomainOperation> InputMapTarget::makeDeleteBinding(const ObjectId& id) const {
    auto       c      = *this;
    const auto before = c.bindings_.size();
    std::erase_if(c.bindings_, [&](const auto& b) { return b.id == id; });
    if (before == c.bindings_.size())
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.input.binding"),
                                                     "Input binding does not exist");
    return replacement(c.contentValue());
}
std::vector<EditorDiagnostic> InputMapTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    std::set<std::string>         ids, names, controls;
    for (const auto& a : actions_) {
        if (a.id.empty() || a.name.empty() || !ids.insert(a.id.value()).second || !names.insert(a.name).second ||
            (a.kind != "button" && a.kind != "axis1d"))
            d.push_back(eve::editing::ruleDiagnostic(
                eve::DiagnosticCode::PreconditionViolation, RuleId("editor.input.action"),
                DiagnosticSeverity::Error, "Action IDs/names must be unique and kinds supported"));
    }
    for (const auto& b : bindings_) {
        const bool target =
            std::any_of(actions_.begin(), actions_.end(), [&](const auto& a) { return a.id == b.action; });
        if (b.id.empty() || !ids.insert(b.id.value()).second || !target || b.control.empty() ||
            !std::isfinite(b.scale) || b.scale == 0 || std::abs(b.scale) > 100 || !std::isfinite(b.deadzone) ||
            b.deadzone < 0 || b.deadzone >= 1)
            d.push_back(eve::editing::ruleDiagnostic(
                eve::DiagnosticCode::PreconditionViolation, RuleId("editor.input.binding"),
                DiagnosticSeverity::Error, "Binding identity, reference or response is invalid"));
        const std::string key = b.device + ":" + b.control;
        if (!controls.insert(key).second)
            d.push_back(eve::editing::ruleDiagnostic(
                eve::DiagnosticCode::Conflict, RuleId("editor.input.conflict"),
                DiagnosticSeverity::Warning, "Control is bound more than once: " + key));
    }
    if (actions_.size() > 1024 || bindings_.size() > 8192)
        d.push_back(eve::editing::ruleDiagnostic(
            eve::DiagnosticCode::PreconditionViolation, RuleId("editor.input.budget"),
            DiagnosticSeverity::Error, "Input map exceeds action or binding budget"));
    return d;
}
Result<void> InputMapTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "input-map.replace.v1" ||
        !op.payload.isWithinLimits(5, 50000, 4 * 1024 * 1024))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.input.operation"),
                                          "Input map operation is invalid");
    auto *av = field(op.payload, "actions"), *bv = field(op.payload, "bindings");
    auto* aa = av ? av->getIf<EditorValue::Array>() : nullptr;
    auto* ba = bv ? bv->getIf<EditorValue::Array>() : nullptr;
    if (!aa || !ba || aa->size() > 1024 || ba->size() > 8192)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.input.payload"),
                                          "Input map payload exceeds limits");
    InputMapTarget c(id_);
    for (const auto& v : *aa) {
        auto *i = field(v, "id"), *n = field(v, "name"), *k = field(v, "kind");
        auto* is = i ? i->getIf<std::string>() : nullptr;
        auto* ns = n ? n->getIf<std::string>() : nullptr;
        auto* ks = k ? k->getIf<std::string>() : nullptr;
        if (!is || !ns || !ks)
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.input.action"),
                                              "Input action payload is invalid");
        c.actions_.push_back({ObjectId(*is), *ns, *ks});
    }
    for (const auto& v : *ba) {
        auto *i = field(v, "id"), *a = field(v, "action"), *dev = field(v, "device"), *ctl = field(v, "control"),
             *scale = field(v, "scale"), *dead = field(v, "deadzone"), *inv = field(v, "invert");
        auto* is = i ? i->getIf<std::string>() : nullptr;
        auto* as = a ? a->getIf<std::string>() : nullptr;
        auto* ds = dev ? dev->getIf<std::string>() : nullptr;
        auto* cs = ctl ? ctl->getIf<std::string>() : nullptr;
        auto* sn = scale ? scale->getIf<double>() : nullptr;
        auto* dn = dead ? dead->getIf<double>() : nullptr;
        auto* ib = inv ? inv->getIf<bool>() : nullptr;
        if (!is || !as || !ds || !cs || !sn || !dn || !ib)
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.input.binding"),
                                              "Input binding payload is invalid");
        c.bindings_.push_back({ObjectId(*is), ObjectId(*as), *ds, *cs, *sn, *dn, *ib});
    }
    if (errors(c.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.input.invalid"),
                                          "Input map validation failed");
    actions_  = std::move(c.actions_);
    bindings_ = std::move(c.bindings_);
    ++revision_;
    dirty_.include(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> InputMapTarget::cloneDomainState() const {
    return std::make_unique<InputMapTarget>(*this);
}
Result<void> InputMapTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> c) {
    auto* t = dynamic_cast<InputMapTarget*>(c.get());
    if (!t || t->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.input.candidate"),
                                          "Input candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
EditorValue InputMapTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> InputMapTarget::loadSnapshot(const EditorValue& s) {
    auto *v = field(s, "schemaVersion"), *c = field(s, "content");
    auto* n = v ? v->getIf<int64_t>() : nullptr;
    if (!n || *n != 1 || !c)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.input.snapshot"),
                                          "Unsupported input snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "input-map.replace.v1";
    op.payload  = *c;
    auto result = applyDomainOperation(op);
    if (result.ok()) dirty_.clear();
    return result;
}
Result<std::map<std::string, double>> InputMapEvaluator::evaluate(
    const InputMapTarget& t, const std::vector<InputControlSample>& samples) const {
    if (errors(t.validate()))
        return eve::editing::failed<std::map<std::string, double>>(
            EditorStatus::Rejected, RuleId("editor.input.invalid"), "Cannot evaluate invalid input map");
    std::map<std::string, double> out;
    for (const auto& a : t.actions()) out[a.name] = 0;
    for (const auto& b : t.bindings()) {
        auto s = std::find_if(samples.begin(), samples.end(),
                              [&](const auto& x) { return x.device == b.device && x.control == b.control; });
        if (s == samples.end()) continue;
        double value = std::clamp(s->value, -1.0, 1.0);
        if (std::abs(value) <= b.deadzone)
            value = 0;
        else
            value = std::copysign((std::abs(value) - b.deadzone) / (1 - b.deadzone), value);
        if (b.invert) value = -value;
        value *= b.scale;
        auto a = std::find_if(t.actions().begin(), t.actions().end(), [&](const auto& x) { return x.id == b.action; });
        if (a->kind == "button")
            out[a->name] = std::max(out[a->name], std::abs(value) >= .5 ? 1.0 : 0.0);
        else
            out[a->name] = std::clamp(out[a->name] + value, -1.0, 1.0);
    }
    return eve::editing::applied<std::map<std::string, double>>(std::move(out));
}
void InputBindingCapture::begin(std::string device) {
    active_ = true;
    device_ = std::move(device);
}
void InputBindingCapture::cancel() {
    active_ = false;
    device_.clear();
}
std::optional<InputControlSample> InputBindingCapture::feed(InputControlSample s) {
    if (!active_ || (!device_.empty() && s.device != device_) || s.control.empty() || !std::isfinite(s.value) ||
        std::abs(s.value) < .5)
        return {};
    cancel();
    return s;
}
}  // namespace eve::input_editing