EvpackSceneTemplateLoader.cpp

浏览该文件的文档.

#include "asset/scene/EvpackSceneTemplateLoader.h"
 
#include "common/Value.h"
#include "asset/RuntimeDefinition.h"
 
#include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <functional>
#include <limits>
#include <map>
#include <set>
 
namespace eve::asset_scene {
namespace {
 
const Value* field(const Value::Object& object, std::string_view name) {
    const auto found = object.find(std::string(name));
    return found == object.end() ? nullptr : &found->second;
}
 
bool number(const Value& value, float& result) {
    if (!value.isNumeric()) return false;
    const double decoded = value.isInt64() ? double(value.asInt()) : value.asDouble();
    if (!std::isfinite(decoded) || decoded < -std::numeric_limits<float>::max() ||
        decoded > std::numeric_limits<float>::max())
        return false;
    result = static_cast<float>(decoded);
    return true;
}
 
bool validGuid(std::string_view value) {
    return value.size() == 32 && std::all_of(value.begin(), value.end(), [](unsigned char character) {
               return std::isxdigit(character) != 0;
           });
}
 
template <std::size_t N>
bool vector(const Value* value, std::array<float, N>& result) {
    const auto* values = value ? value->getIf<Value::Array>() : nullptr;
    if (!values || values->size() != N) return false;
    for (std::size_t i = 0; i < N; ++i)
        if (!number((*values)[i], result[i])) return false;
    return true;
}
 
struct FlatNode {
    std::uint64_t sourceId = 0;
    std::uint64_t parentId = 0;
    scene::NodeDesc desc;
};
 
}  // namespace
 
Result<LoadedSceneTemplate> EvpackSceneTemplateLoader::load(
    const AssetRef& sceneTemplate, const asset::EvpackCapabilities& capabilities,
    const SceneTemplateLoadLimits& limits) const {
    auto payload = reader_.read(sceneTemplate, "eve.scene-template/3", capabilities, limits.maximumDecodedBytes);
    // N-1 packs remain readable with legacy all-on shadow defaults.
    if (!payload && payload.error()->code() == DiagnosticCode::TypeMismatch)
        payload = reader_.read(sceneTemplate, "eve.scene-template/2", capabilities, limits.maximumDecodedBytes);
    if (!payload) return Result<LoadedSceneTemplate>::failure(payload.status());
    const asset::RuntimeAssetChunk* definition = nullptr;
    for (const auto& chunk : payload.value().chunks) {
        if (chunk.kind != asset::EvpackChunkKind::Definition) continue;
        if (definition)
            return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                DiagnosticCode::Conflict, "scene template has duplicate definitions", {}, {}, "asset.scene.template"));
        definition = &chunk;
    }
    if (!definition)
        return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
            DiagnosticCode::NotFound, "scene template definition is missing", {}, {}, "asset.scene.template"));
    asset::RuntimeDefinitionLimits definitionLimits;
    definitionLimits.maximumBytes = limits.maximumDecodedBytes;
    auto metadata = asset::decodeRuntimeDefinition(definition->bytes, definitionLimits);
    if (!metadata) return Result<LoadedSceneTemplate>::failure(metadata.status());
    const auto* root = metadata.value().getIf<Value::Object>();
    const Value* schema = root ? field(*root, "schema") : nullptr;
    const Value* version = root ? field(*root, "schemaVersion") : nullptr;
    const Value* sourceGuid = root ? field(*root, "sourceGuid") : nullptr;
    const Value* coordinate = root ? field(*root, "coordinateSystem") : nullptr;
    const Value* nodesValue = root ? field(*root, "nodes") : nullptr;
    const auto* nodes = nodesValue ? nodesValue->getIf<Value::Array>() : nullptr;
    if (!schema || !schema->isString() || schema->asString() != "eve.scene-template" || !version ||
        !version->isInt64() || version->asInt() != std::int64_t(payload.value().schemaVersion.value()) ||
        (sourceGuid && (!sourceGuid->isString() || !validGuid(sourceGuid->asString()))) || !coordinate ||
        !coordinate->isString() || coordinate->asString() != "right-handed-x-right-y-up-minus-z-forward" || !nodes ||
        nodes->empty() || nodes->size() > limits.maximumNodes)
        return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
            DiagnosticCode::ParseError, "scene-template metadata is invalid", {}, {}, "asset.scene.template"));
    std::map<std::uint64_t, FlatNode> flat;
    std::set<SceneObjectId>           objectIds;
    constexpr float radiansToDegrees = 57.29577951308232f;
    for (std::size_t i = 0; i < nodes->size(); ++i) {
        const auto* node = (*nodes)[i].getIf<Value::Object>();
        const Value* sourceId = node ? field(*node, "sourceFileId") : nullptr;
        const Value* parentId = node ? field(*node, "parentSourceFileId") : nullptr;
        const Value* objectId = node ? field(*node, "objectId") : nullptr;
        const Value* name = node ? field(*node, "name") : nullptr;
        std::array<float, 3> position{}, scale{};
        std::array<float, 4> rotation{};
        if (!sourceId || !sourceId->isInt64() || sourceId->asInt() <= 0 || !parentId ||
            !parentId->isInt64() || parentId->asInt() < 0 || !objectId || !objectId->isString() ||
            !name || !name->isString() || !vector(node ? field(*node, "position") : nullptr, position) ||
            !vector(node ? field(*node, "rotation") : nullptr, rotation) ||
            !vector(node ? field(*node, "scale") : nullptr, scale))
            return Result<LoadedSceneTemplate>::failure(
                Diagnostic::error(DiagnosticCode::ParseError, "scene node is malformed",
                                  "$.nodes[" + std::to_string(i) + "]", {}, "asset.scene.template"));
        auto persistentId = SceneObjectId::parse(objectId->asString());
        const float length = std::sqrt(rotation[0] * rotation[0] + rotation[1] * rotation[1] +
                                       rotation[2] * rotation[2] + rotation[3] * rotation[3]);
        if (!persistentId || persistentId->isNil() || length < 0.999f || length > 1.001f ||
            scale[0] == 0.f || scale[1] == 0.f || scale[2] == 0.f)
            return Result<LoadedSceneTemplate>::failure(
                Diagnostic::error(DiagnosticCode::InvalidArgument, "scene identity, rotation, or scale is invalid",
                                  "$.nodes[" + std::to_string(i) + "]", {}, "asset.scene.template"));
        const float x = rotation[0] / length, y = rotation[1] / length;
        const float z = rotation[2] / length, w = rotation[3] / length;
        // Scene TransformSystem composes Ry * Rx * Rz, not the common Rz * Ry * Rx convention.
        const float     sinPitch = std::clamp(2.f * (w * x - y * z), -1.f, 1.f);
        const float     pitch    = std::asin(sinPitch);
        const bool      gimbal   = std::abs(sinPitch) > 0.999999f;
        const float     yaw      = gimbal ? std::atan2(2.f * (w * y - x * z), 1.f - 2.f * (y * y + z * z))
                                          : std::atan2(2.f * (x * z + w * y), 1.f - 2.f * (x * x + y * y));
        const float     roll     = gimbal ? 0.f : std::atan2(2.f * (x * y + w * z), 1.f - 2.f * (x * x + z * z));
        scene::NodeDesc desc;
        desc.id = std::to_string(sourceId->asInt());
        desc.key = desc.id;
        desc.name = name->asString();
        if (const auto* visible = field(*node, "visible")) {
            if (!visible->isBool())
                return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                    DiagnosticCode::ParseError, "invalid node visibility", {}, {}, "asset.scene.template"));
            desc.visible = visible->asBool();
        }
        desc.persistentId = *persistentId;
        if (!objectIds.insert(*persistentId).second)
            return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                DiagnosticCode::Conflict, "duplicate scene object identity", {}, {}, "asset.scene.template"));
        desc.withPosition(position[0], position[1], position[2])
            .withRotation(yaw * radiansToDegrees, pitch * radiansToDegrees,
                          roll * radiansToDegrees)
            .withScaleXYZ(scale[0], scale[1], scale[2]);
        const std::uint64_t id = static_cast<std::uint64_t>(sourceId->asInt());
        if (!flat.emplace(id, FlatNode{id, static_cast<std::uint64_t>(parentId->asInt()),
                                       std::move(desc)}).second)
            return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                DiagnosticCode::Conflict, "scene contains duplicate sourceFileId", {}, {}, "asset.scene.template"));
    }
    for (const auto& [id, node] : flat)
        if (node.parentId != 0 && !flat.contains(node.parentId))
            return Result<LoadedSceneTemplate>::failure(
                Diagnostic::error(DiagnosticCode::NotFound, "scene parent does not exist", std::to_string(id), {},
                                  "asset.scene.template"));
    std::set<std::uint64_t> visiting, completed;
    std::function<Result<scene::NodeDesc>(std::uint64_t, std::uint32_t)> build =
        [&](std::uint64_t id, std::uint32_t depth) -> Result<scene::NodeDesc> {
        if (depth > limits.maximumDepth)
            return Result<scene::NodeDesc>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,
                                                                      "scene hierarchy exceeds depth budget", {}, {},
                                                                      "asset.scene.template"));
        if (!visiting.emplace(id).second)
            return Result<scene::NodeDesc>::failure(Diagnostic::error(
                DiagnosticCode::Conflict, "scene hierarchy contains a cycle", {}, {}, "asset.scene.template"));
        scene::NodeDesc result = flat.at(id).desc;
        for (const auto& [childId, child] : flat) {
            if (child.parentId != id) continue;
            auto built = build(childId, depth + 1);
            if (!built) return built;
            result.children.push_back(std::move(built).takeValue());
        }
        visiting.erase(id);
        completed.emplace(id);
        return Result<scene::NodeDesc>::success(std::move(result));
    };
    scene::NodeDesc resultRoot;
    resultRoot.id = "asset-root";
    resultRoot.key = "asset-root";
    resultRoot.name = "Asset Scene Template";
    for (const auto& [id, node] : flat) {
        if (node.parentId != 0) continue;
        auto built = build(id, 1);
        if (!built) return Result<LoadedSceneTemplate>::failure(built.status());
        resultRoot.children.push_back(std::move(built).takeValue());
    }
    if (resultRoot.children.empty() || completed.size() != flat.size())
        return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
            DiagnosticCode::Conflict, "scene hierarchy has no valid root", {}, {}, "asset.scene.template"));
    std::vector<SceneMeshBinding> bindings;
    const Value*                  renderersValue = field(*root, "renderers");
    if (version->asInt() == 2 || version->asInt() == 3) {
        const auto* renderers = renderersValue ? renderersValue->getIf<Value::Array>() : nullptr;
        if (!renderers || renderers->size() > limits.maximumNodes)
            return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                DiagnosticCode::ParseError, "invalid renderer bindings", {}, {}, "asset.scene.template"));
        std::set<SceneObjectId> bound;
        for (const auto& value : *renderers) {
            const auto* binding  = value.getIf<Value::Object>();
            const auto* id       = binding ? field(*binding, "objectId") : nullptr;
            const auto* mesh     = binding ? field(*binding, "mesh") : nullptr;
            const auto* material = binding ? field(*binding, "material") : nullptr;
            const auto* enabled  = binding ? field(*binding, "enabled") : nullptr;
            const auto* castShadows = binding ? field(*binding, "castShadows") : nullptr;
            const auto* receiveShadows = binding ? field(*binding, "receiveShadows") : nullptr;
            if (!id || !id->isString() || !mesh || !mesh->isString() || !material || !material->isString() ||
                !enabled || !enabled->isBool() ||
                (version->asInt() == 3 && (!castShadows || !castShadows->isBool() ||
                                           !receiveShadows || !receiveShadows->isBool())))
                return Result<LoadedSceneTemplate>::failure(Diagnostic::error(
                    DiagnosticCode::ParseError, "malformed renderer binding", {}, {}, "asset.scene.template"));
            auto       object        = SceneObjectId::parse(id->asString());
            auto       meshRef       = AssetRef::parse(mesh->asString());
            auto       materialRef   = AssetRef::parse(material->asString());
            const bool meshValid     = meshRef.ok();
            const bool materialValid = materialRef.ok();
            if (!object || !objectIds.contains(*object) || !bound.insert(*object).second || !meshValid ||
                !materialValid)
                return Result<LoadedSceneTemplate>::failure(
                    Diagnostic::error(DiagnosticCode::ParseError, "renderer identity or reference is invalid", {}, {},
                                      "asset.scene.template"));
            bindings.push_back(
                {*object, std::move(meshRef).takeValue(), std::move(materialRef).takeValue(), enabled->asBool(),
                 version->asInt() == 2 || castShadows->asBool(),
                 version->asInt() == 2 || receiveShadows->asBool()});
        }
    }
    return Result<LoadedSceneTemplate>::success(
        {sceneTemplate, sourceGuid ? sourceGuid->asString() : std::string{}, std::move(resultRoot),
         std::move(payload).takeValue().variant,
         std::move(bindings)});
}
 
}  // namespace eve::asset_scene