SceneImportTarget.cpp

浏览该文件的文档.

#include "scene/loader/editing/SceneImportTarget.h"
#include <algorithm>
#include <utility>
namespace eve::sceneloader_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;
}
PropertyDescriptor prop(const char* p, PropertyType t, EditorValue d, const char* c) {
    PropertyDescriptor x;
    x.path           = PropertyPath(p);
    x.displayNameKey = std::string("editor.scene-import.") + p;
    x.category       = c;
    x.type           = t;
    x.defaultValue   = std::move(d);
    x.flags          = PropertyFlag::EditorOnly;
    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
SceneImportTarget::SceneImportTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor SceneImportTarget::describe() const {
    return {TargetId(id_),
            "scene-import",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.scene-import-properties")}};
}
void* SceneImportTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.scene-import-properties") ? static_cast<IPropertyProvider*>(this)
                                                                          : nullptr;
}
bool SceneImportTarget::matches(const SelectionSnapshot& s) const {
    return s.items.size() == 1 && s.items[0].target == TargetId(id_) && s.items[0].type == "scene-import";
}
eve::Result<eve::Revision> SceneImportTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "Scene import selection mismatch", "editor.scene-import.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema SceneImportTarget::schema(const SelectionSnapshot&) const {
    PropertySchema s;
    s.typeId                         = "scene-import";
    s.properties                     = {prop("source", PropertyType::AssetRef, "", "source"),
                                        prop("preset", PropertyType::Enum, "balanced", "source"),
                                        prop("triangulate", PropertyType::Bool, true, "geometry"),
                                        prop("generateNormals", PropertyType::Bool, true, "geometry"),
                                        prop("joinVertices", PropertyType::Bool, true, "geometry"),
                                        prop("flipUvs", PropertyType::Bool, true, "geometry"),
                                        prop("improveCache", PropertyType::Bool, true, "geometry"),
                                        prop("sharedMeshes", PropertyType::Bool, true, "runtime"),
                                        prop("mipmaps", PropertyType::Bool, true, "runtime"),
                                        prop("importLights", PropertyType::Bool, true, "content"),
                                        prop("importCameras", PropertyType::Bool, false, "content"),
                                        prop("importAnimations", PropertyType::Bool, true, "content")};
    s.properties[0].assetTypeFilters = {"model3d", "scene"};
    s.properties[1].enumItems        = {"quality", "balanced", "mobile", "raw", "custom"};
    return s;
}
EditorValue SceneImportTarget::contentValue() const {
    return EditorValue::Object{{"source", value_.sourceAsset},
                               {"preset", value_.preset},
                               {"triangulate", value_.triangulate},
                               {"generateNormals", value_.generateNormals},
                               {"joinVertices", value_.joinVertices},
                               {"flipUvs", value_.flipUvs},
                               {"improveCache", value_.improveCache},
                               {"sharedMeshes", value_.sharedMeshes},
                               {"mipmaps", value_.mipmaps},
                               {"importLights", value_.importLights},
                               {"importCameras", value_.importCameras},
                               {"importAnimations", value_.importAnimations}};
}
PropertyReadResult SceneImportTarget::read(const SelectionSnapshot& s, const PropertyPath& p) const {
    if (!matches(s)) return {};
    const auto content = contentValue();
    auto*      v       = field(content, p.value().c_str());
    return v ? PropertyReadResult{PropertyReadState::Value, *v, {}} : PropertyReadResult{};
}
Result<DomainOperation> SceneImportTarget::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.scene-import.set"),
                                                     "Scene import property edit is invalid");
    EditorValue payload = contentValue();
    auto&       object  = *payload.getIf<EditorValue::Object>();
    object[p.value()]   = v;
    if (p == PropertyPath("preset")) {
        const auto& name = *v.getIf<std::string>();
        if (name != "custom") {
            const bool raw = name == "raw", mobile = name == "mobile";
            object["triangulate"]      = true;
            object["generateNormals"]  = !raw;
            object["joinVertices"]     = !raw;
            object["flipUvs"]          = !raw;
            object["improveCache"]     = !raw;
            object["sharedMeshes"]     = !raw;
            object["mipmaps"]          = !raw;
            object["importLights"]     = !raw && !mobile;
            object["importCameras"]    = false;
            object["importAnimations"] = !raw && !mobile;
        }
    } else
        object["preset"] = "custom";
    DomainOperation op;
    op.type        = "scene-import.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(payload);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    op.affectedProperties.push_back(p.value());
    op.mergeKey = "scene-import:" + id_ + ":" + p.value();
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> SceneImportTarget::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.scene-import.property"),
                                                     "Unknown scene import property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
std::vector<EditorDiagnostic> SceneImportTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    if (value_.sourceAsset.empty())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.scene-import.source"), DiagnosticSeverity::Error, "Scene import requires a source asset"));
    const auto presets = std::vector<std::string>{"quality", "balanced", "mobile", "raw", "custom"};
    if (std::find(presets.begin(), presets.end(), value_.preset) == presets.end())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.scene-import.preset"), DiagnosticSeverity::Error, "Unknown scene import preset"));
    if (!value_.triangulate)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::Unsupported,
            RuleId("editor.scene-import.non-triangles"), DiagnosticSeverity::Warning,
            "Disabled triangulation may produce meshes unsupported by render backends"));
    if (!value_.generateNormals)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.scene-import.normals"), DiagnosticSeverity::Warning,
            "Missing source normals will remain missing"));
    return d;
}
Result<void> SceneImportTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "scene-import.replace.v1" || !op.payload.isWithinLimits(3, 32, 4096))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.scene-import.operation"),
                                          "Scene import operation is invalid");
    SceneImportValue v;
    const auto *     s = field(op.payload, "source"), *p = field(op.payload, "preset");
    auto*            ss = s ? s->getIf<std::string>() : nullptr;
    auto*            ps = p ? p->getIf<std::string>() : nullptr;
    if (!ss || !ps)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.scene-import.payload"),
                                          "Scene import source or preset is invalid");
    v.sourceAsset      = *ss;
    v.preset           = *ps;
    bool*       dst[]  = {&v.triangulate,  &v.generateNormals, &v.joinVertices, &v.flipUvs,       &v.improveCache,
                          &v.sharedMeshes, &v.mipmaps,         &v.importLights, &v.importCameras, &v.importAnimations};
    const char* keys[] = {"triangulate",  "generateNormals", "joinVertices", "flipUvs",       "improveCache",
                          "sharedMeshes", "mipmaps",         "importLights", "importCameras", "importAnimations"};
    for (int i = 0; i < 10; ++i) {
        auto* x = field(op.payload, keys[i]);
        auto* b = x ? x->getIf<bool>() : nullptr;
        if (!b)
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.scene-import.boolean"),
                                              "Scene import option is invalid");
        *dst[i] = *b;
    }
    SceneImportTarget c(id_);
    c.value_ = v;
    if (errors(c.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.scene-import.invalid"),
                                          "Scene import settings validation failed");
    value_ = std::move(v);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> SceneImportTarget::cloneDomainState() const {
    return std::make_unique<SceneImportTarget>(*this);
}
Result<void> SceneImportTarget::commitDomainState(std::unique_ptr<IDomainOperationTarget> c) {
    auto* t = dynamic_cast<SceneImportTarget*>(c.get());
    if (!t || t->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.scene-import.candidate"),
                                          "Scene import candidate mismatch");
    *this = *t;
    return eve::editing::applied<void>();
}
EditorValue SceneImportTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> SceneImportTarget::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.scene-import.snapshot"),
                                          "Unsupported scene import snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "scene-import.replace.v1";
    op.payload  = *c;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
}  // namespace eve::sceneloader_editing