decode()

bool MayaFlux::Nexus::StateDecoder::decode	(	Fabric &	fabric,
		const std::string &	base_path
	)

Decode and apply to fabric.

Parameters

fabric	Target fabric. Must already contain entities with ids matching the schema. Expanses are restored too; one that matches an Expanse already on the Fabric is left in place and only has its box updated.
base_path	Path stem without extension, same value passed to StateEncoder::encode.

Returns

True on success. Partial patches (some ids missing) still return true; failures are logged.

Definition at line 676 of file Decoder.cpp.

{
    m_last_error.clear();
    m_patched_count = 0;
    m_missing_count = 0;
 
    const std::string json_path = base_path + ".json";
    const std::string exr_path = base_path + ".exr";
 
    IO::JSONSerializer ser;
    auto schema_opt = ser.read<State::FabricSchema>(json_path);
    if (!schema_opt) {
        m_last_error = "Failed to load schema: " + ser.last_error();
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
    const auto& schema = *schema_opt;
 
    if (!version_supported(schema.version)) {
        m_last_error = version_error(schema.version);
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    if (schema.entities.empty()) {
        m_last_error = "Schema contains no entities: " + json_path;
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
 
    auto pv_opt = load_exr(exr_path, static_cast<uint32_t>(schema.entities.size()), State::k_exr_rows, m_last_error);
    if (!pv_opt) {
        MF_ERROR(Journal::Component::Nexus, Journal::Context::FileIO, m_last_error);
        return false;
    }
    const auto* pixels = pv_opt->image.as_float();
    const uint32_t width = pv_opt->width;
 
    std::vector<std::string> warnings;
    note_older_version(schema.version, warnings);
 
    for (size_t i = 0; i < schema.entities.size(); ++i) {
        const auto& entry = schema.entities[i];
 
        if (!State::kind_known(entry.kind)) {
            warnings.push_back("unknown kind '" + entry.kind + "' for id "
                + std::to_string(entry.id) + ", skipping");
            ++m_missing_count;
            continue;
        }
 
        const Fields fields = read_fields(entry, *pixels, width, i, schema.ranges);
        if (patch_entity(fabric, entry, fields, warnings)) {
            ++m_patched_count;
        } else {
            warnings.push_back("id " + std::to_string(entry.id) + " not found as "
                + entry.kind + ", skipping");
            ++m_missing_count;
        }
    }
 
    for (const auto& xrec : schema.expanses) {
        restore_expanse(fabric, xrec, warnings);
    }
 
    log_warnings(warnings);
 
    MF_INFO(Journal::Component::Nexus, Journal::Context::FileIO,
        "StateDecoder: patched {} entities ({} missing) from {} + {}",
        m_patched_count, m_missing_count, exr_path, json_path);
 
    return true;
}

References MayaFlux::Journal::FileIO, MayaFlux::Nexus::State::k_exr_rows, MayaFlux::Nexus::State::kind_known(), MayaFlux::IO::JSONSerializer::last_error(), m_last_error, m_missing_count, m_patched_count, MF_ERROR, MF_INFO, MayaFlux::Journal::Nexus, pixels, MayaFlux::IO::JSONSerializer::read(), and width.

Here is the call graph for this function: