VirtualGeometryTarget.cpp

浏览该文件的文档.

#include "virtualgeometry/editing/VirtualGeometryTarget.h"
 
#include <algorithm>
#include <cmath>
#include <utility>
 
namespace eve::virtualgeometry_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;
}
PropertyDescriptor prop(std::string path, PropertyType type, EditorValue value, const char* category, double minimum,
                        double maximum) {
    PropertyDescriptor d;
    d.path            = PropertyPath(path);
    d.displayNameKey  = "editor.virtualgeometry." + 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>& d) {
    return std::any_of(d.begin(), d.end(), [](const auto& v) { return v.severity() == DiagnosticSeverity::Error; });
}
}  // namespace
VirtualGeometryDocumentTarget::VirtualGeometryDocumentTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor VirtualGeometryDocumentTarget::describe() const {
    return {TargetId(id_),
            "virtualgeometry-import",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.virtualgeometry-properties")}};
}
void* VirtualGeometryDocumentTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.virtualgeometry-properties") ? static_cast<IPropertyProvider*>(this)
                                                                             : nullptr;
}
bool VirtualGeometryDocumentTarget::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> VirtualGeometryDocumentTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(eve::DiagnosticCode::InvalidArgument,
                                                                          "VirtualGeometry selection mismatch",
                                                                          "editor.virtualgeometry.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema VirtualGeometryDocumentTarget::schema(const SelectionSnapshot&) const {
    PropertySchema s;
    s.typeId     = "virtualgeometry.import";
    s.properties = {prop("source.asset", PropertyType::AssetRef, "", "source", 0, 0),
                    prop("cluster.maxVertices", PropertyType::Int, int64_t{64}, "cluster", 3, 256),
                    prop("cluster.maxTriangles", PropertyType::Int, int64_t{124}, "cluster", 1, 512),
                    prop("lod.levels", PropertyType::Int, int64_t{4}, "lod", 1, 16),
                    prop("lod.mergeFactor", PropertyType::Int, int64_t{4}, "lod", 2, 4),
                    prop("lod.targetRatio", PropertyType::Float, .5, "lod", .01, .99),
                    prop("preview.fov", PropertyType::Float, 60.0, "preview", 1, 179),
                    prop("preview.height", PropertyType::Int, int64_t{1080}, "preview", 16, 16384),
                    prop("preview.errorPixels", PropertyType::Float, 1.0, "preview", .01, 100),
                    prop("preview.nearDistance", PropertyType::Float, 1.0, "preview", .001, 1e9),
                    prop("preview.farDistance", PropertyType::Float, 1000.0, "preview", .001, 1e9),
                    prop("preview.samples", PropertyType::Int, int64_t{32}, "preview", 2, 512)};
    s.properties[0].assetTypeFilters = {"model3d", "mesh"};
    return s;
}
EditorValue VirtualGeometryDocumentTarget::contentValue() const {
    const auto& v = value_;
    return EditorValue::Object{{"source", v.sourceAsset},
                               {"maxVertices", int64_t{v.builder.maxVerticesPerCluster}},
                               {"maxTriangles", int64_t{v.builder.maxTrianglesPerCluster}},
                               {"levels", int64_t{v.builder.minLodLevels}},
                               {"mergeFactor", int64_t{v.builder.mergeFactor}},
                               {"targetRatio", v.builder.lodTargetRatio},
                               {"fov", v.previewFov},
                               {"height", int64_t{v.previewHeight}},
                               {"errorPixels", v.errorPixels},
                               {"nearDistance", v.nearDistance},
                               {"farDistance", v.farDistance},
                               {"samples", int64_t{v.distanceSamples}}};
}
PropertyReadResult VirtualGeometryDocumentTarget::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.asset"))
        value = v.sourceAsset;
    else if (p == PropertyPath("cluster.maxVertices"))
        value = int64_t{v.builder.maxVerticesPerCluster};
    else if (p == PropertyPath("cluster.maxTriangles"))
        value = int64_t{v.builder.maxTrianglesPerCluster};
    else if (p == PropertyPath("lod.levels"))
        value = int64_t{v.builder.minLodLevels};
    else if (p == PropertyPath("lod.mergeFactor"))
        value = int64_t{v.builder.mergeFactor};
    else if (p == PropertyPath("lod.targetRatio"))
        value = v.builder.lodTargetRatio;
    else if (p == PropertyPath("preview.fov"))
        value = v.previewFov;
    else if (p == PropertyPath("preview.height"))
        value = int64_t{v.previewHeight};
    else if (p == PropertyPath("preview.errorPixels"))
        value = v.errorPixels;
    else if (p == PropertyPath("preview.nearDistance"))
        value = v.nearDistance;
    else if (p == PropertyPath("preview.farDistance"))
        value = v.farDistance;
    else
        value = int64_t{v.distanceSamples};
    return {PropertyReadState::Value, std::move(value), {}};
}
Result<DomainOperation> VirtualGeometryDocumentTarget::replacement(EditorValue content,
                                                                          std::string property) const {
    DomainOperation op;
    op.type        = "virtualgeometry.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 = "virtualgeometry:" + id_ + ":" + property;
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> VirtualGeometryDocumentTarget::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.virtualgeometry.set"),
                                                     "VirtualGeometry property is invalid");
    auto  candidate = *this;
    auto& v         = candidate.value_;
    if (p == PropertyPath("source.asset"))
        v.sourceAsset = *value.getIf<std::string>();
    else if (p == PropertyPath("cluster.maxVertices"))
        v.builder.maxVerticesPerCluster = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("cluster.maxTriangles"))
        v.builder.maxTrianglesPerCluster = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("lod.levels"))
        v.builder.minLodLevels = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("lod.mergeFactor"))
        v.builder.mergeFactor = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("lod.targetRatio"))
        v.builder.lodTargetRatio = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("preview.fov"))
        v.previewFov = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("preview.height"))
        v.previewHeight = static_cast<int>(*value.getIf<int64_t>());
    else if (p == PropertyPath("preview.errorPixels"))
        v.errorPixels = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("preview.nearDistance"))
        v.nearDistance = static_cast<float>(*value.getIf<double>());
    else if (p == PropertyPath("preview.farDistance"))
        v.farDistance = static_cast<float>(*value.getIf<double>());
    else
        v.distanceSamples = static_cast<int>(*value.getIf<int64_t>());
    if (errors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.invalid"),
                                                     "VirtualGeometry edit violates importer invariants");
    return replacement(candidate.contentValue(), p.value());
}
Result<DomainOperation> VirtualGeometryDocumentTarget::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.virtualgeometry.property"), "Unknown VirtualGeometry property");
    return makeSet(s, p, d->defaultValue, PropertySetMode::Absolute);
}
std::vector<EditorDiagnostic> VirtualGeometryDocumentTarget::validate() const {
    std::vector<EditorDiagnostic> d;
    const auto&                   v = value_;
    if (v.sourceAsset.empty())
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
                                                 RuleId("editor.virtualgeometry.source"),
                                                 DiagnosticSeverity::Warning,
                                                 "VirtualGeometry source asset is not assigned"));
    if (v.builder.maxVerticesPerCluster < 3 || v.builder.maxVerticesPerCluster > 256 ||
        v.builder.maxTrianglesPerCluster < 1 || v.builder.maxTrianglesPerCluster > 512 || v.builder.minLodLevels < 1 ||
        v.builder.minLodLevels > 16 || v.builder.mergeFactor < 2 || v.builder.mergeFactor > 4 ||
        !std::isfinite(v.builder.lodTargetRatio) || v.builder.lodTargetRatio <= 0 || v.builder.lodTargetRatio >= 1)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
                                                 RuleId("editor.virtualgeometry.builder"), DiagnosticSeverity::Error,
                                                 "VirtualGeometry builder settings exceed supported invariants"));
    if (!std::isfinite(v.previewFov) || v.previewFov < 1 || v.previewFov > 179 || v.previewHeight < 16 ||
        v.previewHeight > 16384 || !std::isfinite(v.errorPixels) || v.errorPixels <= 0 || v.errorPixels > 100 ||
        !std::isfinite(v.nearDistance) || !std::isfinite(v.farDistance) || v.nearDistance <= 0 ||
        v.farDistance <= v.nearDistance || v.farDistance > 1e9f || v.distanceSamples < 2 || v.distanceSamples > 512)
        d.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
                                                 RuleId("editor.virtualgeometry.preview"), DiagnosticSeverity::Error,
                                                 "VirtualGeometry LOD preview sweep is invalid"));
    return d;
}
Result<void> VirtualGeometryDocumentTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "virtualgeometry.document.replace.v1" ||
        !op.payload.isWithinLimits(4, 64, 4096))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.operation"),
                                          "VirtualGeometry operation is invalid");
    VirtualGeometryImportValue v;
    const auto*                source = field(op.payload, "source");
    const auto*                s      = source ? source->getIf<std::string>() : nullptr;
    if (!s)
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.source"),
                                          "VirtualGeometry source is invalid");
    v.sourceAsset         = *s;
    int*        ints[]    = {&v.builder.maxVerticesPerCluster,
                             &v.builder.maxTrianglesPerCluster,
                             &v.builder.minLodLevels,
                             &v.builder.mergeFactor,
                             &v.previewHeight,
                             &v.distanceSamples};
    const char* ifields[] = {"maxVertices", "maxTriangles", "levels", "mergeFactor", "height", "samples"};
    for (int i = 0; i < 6; ++i) {
        const auto* x = field(op.payload, ifields[i]);
        const auto* n = x ? x->getIf<int64_t>() : nullptr;
        if (!n)
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.integer"),
                                              "VirtualGeometry integer is invalid");
        *ints[i] = static_cast<int>(*n);
    }
    float*      floats[]  = {&v.builder.lodTargetRatio, &v.previewFov, &v.errorPixels, &v.nearDistance, &v.farDistance};
    const char* ffields[] = {"targetRatio", "fov", "errorPixels", "nearDistance", "farDistance"};
    for (int i = 0; i < 5; ++i) {
        const auto* x = field(op.payload, ffields[i]);
        const auto* n = x ? x->getIf<double>() : nullptr;
        if (!n || !std::isfinite(*n))
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.number"),
                                              "VirtualGeometry number is invalid");
        *floats[i] = static_cast<float>(*n);
    }
    VirtualGeometryDocumentTarget candidate(id_);
    candidate.value_ = v;
    if (errors(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.virtualgeometry.invalid"),
                                          "VirtualGeometry document validation failed");
    value_ = std::move(v);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> VirtualGeometryDocumentTarget::cloneDomainState() const {
    return std::make_unique<VirtualGeometryDocumentTarget>(*this);
}
Result<void> VirtualGeometryDocumentTarget::commitDomainState(
    std::unique_ptr<IDomainOperationTarget> candidate) {
    auto* typed = dynamic_cast<VirtualGeometryDocumentTarget*>(candidate.get());
    if (!typed || typed->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.virtualgeometry.candidate"),
                                          "VirtualGeometry candidate mismatch");
    *this = *typed;
    return eve::editing::applied<void>();
}
EditorValue VirtualGeometryDocumentTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> VirtualGeometryDocumentTarget::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.virtualgeometry.snapshot"),
                                          "Unsupported VirtualGeometry snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "virtualgeometry.document.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
}  // namespace eve::virtualgeometry_editing