VirtualGeometryRuntime.cpp

浏览该文件的文档.

#include "virtualgeometry/editing/VirtualGeometryTarget.h"
 
#include "virtualgeometry/LodSelection.h"
#include "virtualgeometry/VirtualGeometryAsset.h"
 
#include <algorithm>
#include <cmath>
#include <cstring>
#include <utility>
 
namespace eve::virtualgeometry_editing {
namespace {
void hashBytes(std::uint64_t& hash, const void* data, std::size_t size) {
    const auto* bytes = static_cast<const unsigned char*>(data);
    for (std::size_t i = 0; i < size; ++i) {
        hash ^= bytes[i];
        hash *= 1099511628211ull;
    }
}
std::uint64_t checksum(const virtualgeometry::VirtualGeometryAsset& a) {
    std::uint64_t hash = 1469598103934665603ull;
    hashBytes(hash, a.positions.data(), a.positions.size() * sizeof(float));
    hashBytes(hash, a.triangles.data(), a.triangles.size() * sizeof(std::uint32_t));
    hashBytes(hash, a.clusters.data(), a.clusters.size() * sizeof(virtualgeometry::VgCluster));
    return hash;
}
}  // namespace
VirtualGeometryBuildRuntime::VirtualGeometryBuildRuntime()  = default;
VirtualGeometryBuildRuntime::~VirtualGeometryBuildRuntime() = default;
Result<VirtualGeometryBuildArtifact> VirtualGeometryBuildRuntime::build(
    const VirtualGeometryDocumentTarget& document, const IVirtualGeometryMeshResolver& resolver) {
    const auto diagnostics = document.validate();
    for (const auto& d : diagnostics)
        if (d.severity() == DiagnosticSeverity::Error)
            return Result<VirtualGeometryBuildArtifact>::failure(
                Status(EditorStatus::Rejected, diagnostics));
    if (document.value().sourceAsset.empty())
        return eve::editing::failed<VirtualGeometryBuildArtifact>(EditorStatus::Rejected,
                                                                  RuleId("editor.virtualgeometry.source"),
                                                                  "VirtualGeometry build requires a source asset");
    auto resolved = resolver.resolve(document.value().sourceAsset);
    if (!resolved.ok())
        return Result<VirtualGeometryBuildArtifact>::failure(resolved.status());
    auto&      mesh           = resolved.value();
    const bool normalsInvalid = !mesh.normals.empty() && mesh.normals.size() != mesh.positions.size();
    if (mesh.positions.empty() || mesh.positions.size() % 3 != 0 || mesh.indices.empty() ||
        mesh.indices.size() % 3 != 0 || mesh.positions.size() / 3 > 50000000 || mesh.indices.size() > 150000000 ||
        normalsInvalid)
        return eve::editing::failed<VirtualGeometryBuildArtifact>(EditorStatus::Rejected,
                                                                  RuleId("editor.virtualgeometry.mesh"),
                                                                  "VirtualGeometry mesh shape or budget is invalid");
    const std::size_t vertices = mesh.positions.size() / 3;
    for (float value : mesh.positions)
        if (!std::isfinite(value))
            return eve::editing::failed<VirtualGeometryBuildArtifact>(EditorStatus::Rejected,
                                                                      RuleId("editor.virtualgeometry.position"),
                                                                      "VirtualGeometry positions must be finite");
    for (std::uint32_t index : mesh.indices)
        if (index >= vertices)
            return eve::editing::failed<VirtualGeometryBuildArtifact>(EditorStatus::Rejected,
                                                                      RuleId("editor.virtualgeometry.index"),
                                                                      "VirtualGeometry index is out of range");
    auto                                    candidate = std::make_unique<virtualgeometry::VirtualGeometryAsset>();
    virtualgeometry::VirtualGeometryBuilder builder;
    virtualgeometry::VirtualGeometryBuilder::MeshInput input;
    input.vertexCount = static_cast<int>(vertices);
    input.positions   = mesh.positions.data();
    input.normals     = mesh.normals.empty() ? nullptr : mesh.normals.data();
    input.indices     = mesh.indices.data();
    input.indexCount  = static_cast<int>(mesh.indices.size());
    if (!builder.build(input, document.value().builder, *candidate))
        return eve::editing::failed<VirtualGeometryBuildArtifact>(
            EditorStatus::Failed, RuleId("editor.virtualgeometry.build"),
            "VirtualGeometry builder rejected the candidate mesh");
    VirtualGeometryBuildArtifact artifact;
    artifact.sourceRevision  = document.revision();
    artifact.vertices        = candidate->vertexCount;
    artifact.sourceTriangles = mesh.indices.size() / 3;
    artifact.storedTriangles = candidate->triangles.size() / 3;
    artifact.clusters        = static_cast<int>(candidate->clusters.size());
    artifact.checksum        = checksum(*candidate);
    for (const auto& cluster : candidate->clusters) {
        artifact.maxLod = std::max(artifact.maxLod, static_cast<int>(cluster.lodLevel));
        if (cluster.parent == 0xFFFFFFFFu) ++artifact.roots;
        if (cluster.childCount > 4 || cluster.triStart + cluster.triCount > candidate->triangles.size() / 3)
            return eve::editing::failed<VirtualGeometryBuildArtifact>(
                EditorStatus::Failed, RuleId("editor.virtualgeometry.dag"),
                "VirtualGeometry builder produced an invalid cluster range");
        for (std::uint32_t i = 0; i < cluster.childCount; ++i)
            if (cluster.children[i] >= candidate->clusters.size())
                return eve::editing::failed<VirtualGeometryBuildArtifact>(
                    EditorStatus::Failed, RuleId("editor.virtualgeometry.dag"),
                    "VirtualGeometry builder produced an invalid child reference");
    }
    const auto&     v      = document.value();
    constexpr float pi     = 3.14159265358979323846f;
    const float projection = static_cast<float>(v.previewHeight) / (2.f * std::tan(v.previewFov * pi / 180.f * .5f));
    for (int sample = 0; sample < v.distanceSamples; ++sample) {
        const float                alpha    = static_cast<float>(sample) / (v.distanceSamples - 1);
        const float                distance = v.nearDistance * std::pow(v.farDistance / v.nearDistance, alpha);
        std::vector<std::uint32_t> selected;
        virtualgeometry::selectClusters(*candidate, distance, projection, v.errorPixels, selected);
        VirtualGeometryLodSample point;
        point.distance = distance;
        point.clusters = static_cast<int>(selected.size());
        for (auto id : selected) point.triangles += candidate->clusters[id].triCount;
        virtualgeometry::lodHistogram(*candidate, selected, point.levelHistogram);
        artifact.lodCurve.push_back(std::move(point));
    }
    asset_             = std::move(candidate);
    revision_          = document.revision();
    return eve::editing::applied<VirtualGeometryBuildArtifact>(std::move(artifact), diagnostics);
}
}  // namespace eve::virtualgeometry_editing