whiteoutlib 0.2.0

Read and write Blizzard game assets from Rust: models (MDX, M2, M3), textures (BLP, DDS, PNG, JPEG, BMP, TGA, TIFF, GIF) and archives (CASC, MPQ).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2026 Fernando Sahmkow

#include "db_internal.h"

#include <cstring>

namespace whiteout::database {

namespace {

const RowEntry* entryOf(const TableData* data, u32 index) {
    return data != nullptr ? data->rowAt(index) : nullptr;
}

} // namespace

u32 Row::id() const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? entry->id : 0;
}

u32 Row::section() const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? entry->section : 0;
}

bool Row::isCopy() const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr && entry->copy;
}

bool Row::isSparse() const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr && entry->sparse;
}

bool Row::isEncrypted() const {
    const RowEntry* entry = entryOf(data_, index_);
    if (entry == nullptr || entry->section >= data_->sections.size()) {
        return false;
    }
    return data_->sections[entry->section].encrypted;
}

std::optional<u32> Row::relationId() const {
    const RowEntry* entry = entryOf(data_, index_);
    if (entry == nullptr || entry->section >= data_->sections.size()) {
        return std::nullopt;
    }
    const SectionData& section = data_->sections[entry->section];
    if (section.relationKeyedById) {
        const auto found = section.relationById.find(entry->lookupId);
        return found != section.relationById.end() ? std::optional<u32>(found->second)
                                                   : std::nullopt;
    }
    if (entry->recordIndex < section.relationByRecord.size()) {
        const u32 value = section.relationByRecord[entry->recordIndex];
        return value != 0 ? std::optional<u32>(value) : std::nullopt;
    }
    return std::nullopt;
}

std::span<const u8> Row::raw() const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? data_->recordBytes(*entry) : std::span<const u8>{};
}

u64 Row::getUInt(u32 field, u32 arrayIndex) const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? data_->fieldValue(*entry, field, arrayIndex, false) : 0;
}

i64 Row::getInt(u32 field, u32 arrayIndex) const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? static_cast<i64>(data_->fieldValue(*entry, field, arrayIndex, true))
                            : 0;
}

f32 Row::getFloat(u32 field, u32 arrayIndex) const {
    const u32 raw = static_cast<u32>(getUInt(field, arrayIndex));
    f32 value = 0.0f;
    std::memcpy(&value, &raw, sizeof(value));
    return value;
}

std::string_view Row::getString(u32 field, u32 arrayIndex) const {
    const RowEntry* entry = entryOf(data_, index_);
    if (entry == nullptr) {
        return {};
    }
    const u32 raw = static_cast<u32>(data_->fieldValue(*entry, field, arrayIndex, false));
    return data_->resolveString(*entry, data_->fieldByteOffset(field, arrayIndex), raw);
}

Value Row::value(u32 column, u32 arrayIndex) const {
    const RowEntry* entry = entryOf(data_, index_);
    return entry != nullptr ? data_->columnValue(*entry, column, arrayIndex) : Value();
}

Value Row::value(std::string_view column, u32 arrayIndex) const {
    if (data_ == nullptr || !data_->schema.has_value()) {
        return Value();
    }
    const auto index = data_->schema->indexOf(column);
    return index.has_value() ? value(*index, arrayIndex) : Value();
}

std::string_view Row::locString(std::string_view column, Locale locale) const {
    return value(column, static_cast<u32>(locale)).asString();
}

} // namespace whiteout::database