whiteoutlib 0.1.1

Read and write Blizzard game assets: models (MDX, M2, M3), textures (BLP, DDS, PNG, ...) 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

#pragma once

#include <cstdint>
#include <cstring>
#include <span>
#include <streambuf>
#include <vector>

#include <whiteout/common_types.h>

namespace whiteout {
namespace common {

class span_streambuf : public std::streambuf {
public:
    span_streambuf(std::span<const u8> data) {
        // setg() requires char* even for input-only streambufs (legacy API).
        // We only ever read via eback()/gptr()/egptr(), so the cast is safe.
        char* begin = const_cast<char*>( // NOLINT(cppcoreguidelines-pro-type-const-cast)
            reinterpret_cast<const char*>(data.data()));
        setg(begin, begin, begin + data.size());
    }

protected:
    pos_type seekoff(off_type off, std::ios_base::seekdir dir,
                     std::ios_base::openmode which = std::ios_base::in) override {
        if (!(which & std::ios_base::in))
            return pos_type(off_type(-1));
        char* newpos;
        switch (dir) {
        case std::ios_base::beg:
            newpos = eback() + off;
            break;
        case std::ios_base::cur:
            newpos = gptr() + off;
            break;
        case std::ios_base::end:
            newpos = egptr() + off;
            break;
        default:
            return pos_type(off_type(-1));
        }
        if (newpos < eback() || newpos > egptr())
            return pos_type(off_type(-1));
        setg(eback(), newpos, egptr());
        return pos_type(newpos - eback());
    }

    pos_type seekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::in) override {
        return seekoff(off_type(pos), std::ios_base::beg, which);
    }
};

class vector_streambuf : public std::streambuf {
public:
    explicit vector_streambuf(std::vector<u8>& buffer) : buffer_(buffer), pos_(buffer.size()) {}

protected:
    // Write a single character
    int overflow(int ch) override {
        if (ch == traits_type::eof())
            return traits_type::not_eof(ch);

        if (pos_ < buffer_.size()) {
            buffer_[pos_] = static_cast<u8>(ch);
        } else {
            buffer_.push_back(static_cast<u8>(ch));
        }
        ++pos_;
        return ch;
    }

    // Write multiple characters
    std::streamsize xsputn(const char* s, std::streamsize count) override {
        auto start = reinterpret_cast<const u8*>(s);
        std::size_t n = static_cast<std::size_t>(count);

        if (pos_ + n <= buffer_.size()) {
            // Overwrite existing data
            std::memcpy(buffer_.data() + pos_, start, n);
        } else if (pos_ < buffer_.size()) {
            // Partial overwrite + append
            std::size_t overwrite = buffer_.size() - pos_;
            std::memcpy(buffer_.data() + pos_, start, overwrite);
            buffer_.insert(buffer_.end(), start + overwrite, start + n);
        } else {
            // Pure append (pos_ may be past end if seeks happened)
            buffer_.insert(buffer_.end(), start, start + n);
        }
        pos_ += n;
        return count;
    }

    pos_type seekoff(off_type off, std::ios_base::seekdir dir,
                     std::ios_base::openmode which = std::ios_base::out) override {
        if (!(which & std::ios_base::out))
            return pos_type(off_type(-1));

        std::size_t newpos;
        switch (dir) {
        case std::ios_base::beg:
            newpos = static_cast<std::size_t>(off);
            break;
        case std::ios_base::cur:
            newpos = pos_ + static_cast<std::size_t>(off);
            break;
        case std::ios_base::end:
            newpos = buffer_.size() + static_cast<std::size_t>(off);
            break;
        default:
            return pos_type(off_type(-1));
        }
        if (newpos > buffer_.size())
            return pos_type(off_type(-1));
        pos_ = newpos;
        return pos_type(static_cast<off_type>(pos_));
    }

    pos_type seekpos(pos_type pos, std::ios_base::openmode which = std::ios_base::out) override {
        return seekoff(off_type(pos), std::ios_base::beg, which);
    }

private:
    std::vector<u8>& buffer_;
    std::size_t pos_;
};

} // namespace common
} // namespace whiteout