TextureRecipeTarget.cpp

浏览该文件的文档.

#include "procgen/editing/TextureRecipeTarget.h"
#include <charconv>
#include <cmath>
#include <cstdlib>
#include <stdexcept>
#include <utility>
#include "image/ImageData.h"
#include "procgen/ParamSchema.h"
#include "procgen/Params.h"
#include "procgen/texture/TextureRecipe.h"
namespace eve::procgen_editing {
namespace {
EditorDiagnostic diagnostic(const char* rule, DiagnosticSeverity severity, std::string message) {
    return eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument, RuleId(rule),
                                        severity, std::move(message));
}
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 defaultValue(const procgen::ParamDescriptor& p) {
    try {
        switch (p.kind) {
            case procgen::ParamKind::Integer: return int64_t{std::stoll(p.defaultValue)};
            case procgen::ParamKind::Float: return std::stod(p.defaultValue);
            case procgen::ParamKind::Boolean: return p.defaultValue == "1" || p.defaultValue == "true";
            case procgen::ParamKind::String:
            case procgen::ParamKind::Choice: return p.defaultValue;
        }
    } catch (...) {
        return {};
    }
    return {};
}
PropertyType propertyType(procgen::ParamKind k) {
    switch (k) {
        case procgen::ParamKind::Integer: return PropertyType::Int;
        case procgen::ParamKind::Float: return PropertyType::Float;
        case procgen::ParamKind::Boolean: return PropertyType::Bool;
        case procgen::ParamKind::Choice: return PropertyType::Enum;
        case procgen::ParamKind::String: return PropertyType::String;
    }
    return PropertyType::String;
}
bool hasErrors(const std::vector<EditorDiagnostic>& d) {
    for (const auto& x : d)
        if (x.severity() == DiagnosticSeverity::Error) return true;
    return false;
}
}  // namespace
TextureRecipeTarget::TextureRecipeTarget(std::string id, std::string recipe)
    : id_(std::move(id)), recipe_(std::move(recipe)) {
    auto initialized = initializeDefaults();
    if (!initialized.ok()) throw std::invalid_argument("Texture recipe is not registered: " + recipe_);
}
Result<void> TextureRecipeTarget::initializeDefaults() {
    auto& r = procgen::TextureRecipeRegistry::instance();
    r.registerBuiltins();
    const auto* d = r.descriptor(recipe_);
    if (!d)
        return eve::editing::failed<void>(EditorStatus::NotFound, RuleId("editor.texture-recipe.unknown"),
                                          "Texture recipe is not registered");
    values_.clear();
    for (const auto& p : d->params) values_[p.key] = defaultValue(p);
    return eve::editing::applied<void>();
}
TargetDescriptor TextureRecipeTarget::describe() const {
    return {TargetId(id_),
            "texture-recipe",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.texture-recipe-properties")}};
}
void* TextureRecipeTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.texture-recipe-properties") ? static_cast<IPropertyProvider*>(this)
                                                                            : nullptr;
}
bool TextureRecipeTarget::matches(const SelectionSnapshot& s) const {
    return s.items.size() == 1 && s.items[0].target == TargetId(id_) && s.items[0].type == "texture-recipe";
}
eve::Result<eve::Revision> TextureRecipeTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,
                                                                          "Texture recipe selection mismatch",
                                                                          "editor.texture-recipe.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema TextureRecipeTarget::schema(const SelectionSnapshot&) const {
    PropertySchema out;
    out.typeId    = "texture-recipe";
    auto&       r = procgen::TextureRecipeRegistry::instance();
    const auto* d = r.descriptor(recipe_);
    if (!d) return out;
    for (const auto& p : d->params) {
        PropertyDescriptor x;
        x.path           = PropertyPath("param." + p.key);
        x.displayNameKey = p.displayName;
        x.descriptionKey = p.description;
        x.category       = p.category;
        x.type           = propertyType(p.kind);
        x.defaultValue   = defaultValue(p);
        x.flags          = PropertyFlag::Runtime;
        x.enumItems      = p.choices;
        if (p.hasMinimum) x.numeric.minimum = p.minimum;
        if (p.hasMaximum) x.numeric.maximum = p.maximum;
        x.numeric.step = p.step;
        out.properties.push_back(std::move(x));
    }
    return out;
}
PropertyReadResult TextureRecipeTarget::read(const SelectionSnapshot& s, const PropertyPath& p) const {
    if (!matches(s) || p.value().rfind("param.", 0) != 0) return {};
    auto i = values_.find(p.value().substr(6));
    return i == values_.end() ? PropertyReadResult{} : PropertyReadResult{PropertyReadState::Value, i->second, {}};
}
EditorValue TextureRecipeTarget::contentValue() const {
    return EditorValue::Object{{"recipe", recipe_}, {"values", values_}};
}
Result<DomainOperation> TextureRecipeTarget::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.texture-recipe.set"),
                                                     "Texture recipe property edit is invalid");
    auto values                 = values_;
    values[p.value().substr(6)] = v;
    DomainOperation op;
    op.type        = "texture-recipe.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = EditorValue::Object{{"recipe", recipe_}, {"values", std::move(values)}};
    op.inverse     = contentValue();
    op.hasInverse  = true;
    op.affectedProperties.push_back(p.value());
    op.mergeKey = "texture-recipe:" + id_ + ":" + p.value();
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> TextureRecipeTarget::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.texture-recipe.property"), "Unknown texture recipe property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
std::vector<EditorDiagnostic> TextureRecipeTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    auto&                         r    = procgen::TextureRecipeRegistry::instance();
    const auto*                   desc = r.descriptor(recipe_);
    if (!desc) {
        d.push_back(diagnostic("editor.texture-recipe.unknown", DiagnosticSeverity::Error,
                               "Texture recipe is not registered"));
        return d;
    }
    const auto s = schema({});
    for (const auto& p : desc->params) {
        auto i = values_.find(p.key);
        auto x = s.find(PropertyPath("param." + p.key));
        if (i == values_.end() || !x || !validatePropertyValue(*x, i->second).ok())
            d.push_back(diagnostic("editor.texture-recipe.parameter", DiagnosticSeverity::Error,
                                   "Invalid texture parameter: " + p.key));
    }
    if (values_.size() != desc->params.size())
        d.push_back(diagnostic("editor.texture-recipe.extra", DiagnosticSeverity::Error,
                               "Texture recipe contains unknown parameters"));
    return d;
}
Result<void> TextureRecipeTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "texture-recipe.replace.v1")
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.texture-recipe.operation"),
                                          "Texture recipe operation is invalid");
    const auto *recipe = field(op.payload, "recipe"), *values = field(op.payload, "values");
    const auto* rs = recipe ? recipe->getIf<std::string>() : nullptr;
    const auto* vo = values ? values->getIf<EditorValue::Object>() : nullptr;
    if (!rs || *rs != recipe_ || !vo || vo->size() > 128)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.texture-recipe.payload"),
                                          "Texture recipe payload is invalid");
    TextureRecipeTarget candidate = *this;
    candidate.values_             = *vo;
    if (hasErrors(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.texture-recipe.invalid"),
                                          "Texture recipe validation failed");
    values_ = std::move(candidate.values_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> TextureRecipeTarget::cloneDomainState() const {
    return std::make_unique<TextureRecipeTarget>(*this);
}
Result<void> TextureRecipeTarget::commitDomainState(
    std::unique_ptr<IDomainOperationTarget> c) {
    auto* t = dynamic_cast<TextureRecipeTarget*>(c.get());
    if (!t || t->id_ != id_ || t->recipe_ != recipe_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.texture-recipe.candidate"),
                                          "Texture recipe candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
EditorValue TextureRecipeTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> TextureRecipeTarget::loadSnapshot(const EditorValue& s) {
    const auto *v = field(s, "schemaVersion"), *c = field(s, "content");
    const auto* version = v ? v->getIf<int64_t>() : nullptr;
    if (!version || *version != 1 || !c)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.texture-recipe.snapshot"),
                                          "Unsupported texture recipe snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "texture-recipe.replace.v1";
    op.payload  = *c;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
TextureRecipePreviewRuntime::TextureRecipePreviewRuntime()  = default;
TextureRecipePreviewRuntime::~TextureRecipePreviewRuntime() = default;
Result<TextureRecipePreviewArtifact> TextureRecipePreviewRuntime::generate(
    const TextureRecipeTarget& target) {
    const auto diagnostics = target.validate();
    if (hasErrors(diagnostics)) {
        return Result<TextureRecipePreviewArtifact>::failure(
            eve::Status(EditorStatus::Rejected, diagnostics));
    }
    procgen::Params params;
    for (const auto& [key, v] : target.values()) {
        if (auto* x = v.getIf<int64_t>())
            params.setInt(key, static_cast<int>(*x));
        else if (auto* x = v.getIf<double>())
            params.setFloat(key, static_cast<float>(*x));
        else if (auto* x = v.getIf<bool>())
            params.setBool(key, *x);
        else if (auto* x = v.getIf<std::string>())
            params.setString(key, *x);
    }
    std::string error;
    auto        candidate = procgen::TextureRecipeRegistry::instance().generate(target.recipe(), params, error);
    if (!candidate)
        return eve::editing::failed<TextureRecipePreviewArtifact>(EditorStatus::Failed,
                                                                  RuleId("editor.texture-recipe.generate"), error);
    std::uint64_t hash  = 1469598103934665603ull;
    auto*         bytes = static_cast<const unsigned char*>(candidate->getData());
    for (std::size_t i = 0; i < candidate->getSize(); ++i) {
        hash ^= bytes[i];
        hash *= 1099511628211ull;
    }
    TextureRecipePreviewArtifact artifact{target.revision(), candidate->getWidth(), candidate->getHeight(), hash};
    image_             = std::move(candidate);
    revision_          = target.revision();
    return eve::editing::applied<TextureRecipePreviewArtifact>(artifact, diagnostics);
}
}  // namespace eve::procgen_editing