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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

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

#include <whiteout/models/wem/anim/channel.h>

namespace whiteout {
namespace models {
namespace wem {

const char* ToString(Channel channel) {
    switch (channel) {
    case Channel::Translation:
        return "translation";
    case Channel::Rotation:
        return "rotation";
    case Channel::Scale:
        return "scale";
    case Channel::Visibility:
        return "visibility";
    case Channel::Color:
        return "color";
    case Channel::Alpha:
        return "alpha";
    case Channel::Intensity:
        return "intensity";
    case Channel::AttenuationStart:
        return "attenuationStart";
    case Channel::AttenuationEnd:
        return "attenuationEnd";
    case Channel::UvTranslate:
        return "uvTranslate";
    case Channel::UvRotate:
        return "uvRotate";
    case Channel::UvScale:
        return "uvScale";
    case Channel::Weight:
        return "weight";
    case Channel::TextureIndex:
        return "textureIndex";
    case Channel::Emissive:
        return "emissive";
    case Channel::Count:
        break;
    }
    return "invalid";
}

const char* ToString(TrackTarget::Kind kind) {
    switch (kind) {
    case TrackTarget::Kind::Node:
        return "node";
    case TrackTarget::Kind::MaterialLayer:
        return "materialLayer";
    case TrackTarget::Kind::MaterialFeature:
        return "materialFeature";
    case TrackTarget::Kind::Section:
        return "section";
    case TrackTarget::Kind::Count:
        break;
    }
    return "invalid";
}

geom::AttrType DefaultValueType(Channel channel) {
    switch (channel) {
    case Channel::Translation:
    case Channel::Scale:
    case Channel::Color:
    case Channel::UvTranslate:
    case Channel::UvScale:
        return geom::AttrType::F32x3;
    case Channel::Rotation:
    case Channel::UvRotate:
        return geom::AttrType::Quat;
    case Channel::TextureIndex:
        return geom::AttrType::U32;
    case Channel::Visibility:
    case Channel::Alpha:
    case Channel::Intensity:
    case Channel::AttenuationStart:
    case Channel::AttenuationEnd:
    case Channel::Weight:
    case Channel::Emissive:
    case Channel::Count:
        break;
    }
    return geom::AttrType::F32;
}

const AnimChannel* AnimChannelTable::find(u32 id) const {
    for (const AnimChannel& channel : channels) {
        if (channel.id == id) {
            return &channel;
        }
    }
    return nullptr;
}

AnimChannel* AnimChannelTable::find(u32 id) {
    const AnimChannelTable& self = *this;
    return const_cast<AnimChannel*>(self.find(id));
}

u32 AnimChannelTable::indexOf(u32 id) const {
    for (std::size_t i = 0; i < channels.size(); ++i) {
        if (channels[i].id == id) {
            return static_cast<u32>(i);
        }
    }
    return kInvalidIndex;
}

u32 AnimChannelTable::add(const AnimChannel& channel) {
    channels.push_back(channel);
    return channel.id;
}

u32 AnimChannelTable::nextFreeId() const {
    // Ids are never reused, so the successor of the largest is free even after
    // channels in the middle have been dropped.
    u32 highest = 0;
    for (const AnimChannel& channel : channels) {
        if (channel.id >= highest) {
            highest = channel.id + 1;
        }
    }
    return highest;
}

} // namespace wem
} // namespace models
} // namespace whiteout