mirror of
https://github.com/luanti-org/luanti.git
synced 2025-11-21 00:45:23 +01:00
94 lines
2.3 KiB
C++
94 lines
2.3 KiB
C++
// Luanti
|
|
// SPDX-License-Identifier: LGPL-2.1-or-later
|
|
// Copyright (C) 2021-2025 sfan5
|
|
|
|
#include "irrlichttypes.h"
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
|
|
/**
|
|
* Rudimentary header-only 2D bitmap class.
|
|
* @warning not thread-safe
|
|
*/
|
|
class Bitmap {
|
|
u32 linesize, lines;
|
|
std::vector<u8> data;
|
|
|
|
static inline u32 bytepos(u32 index) { return index >> 3; }
|
|
static inline u8 bitpos(u32 index) { return index & 7; }
|
|
|
|
template<bool set, bool toggle, bool clear>
|
|
bool modify_(u32 x, u32 y)
|
|
{
|
|
u32 index = y * linesize + x;
|
|
u8 mask = 1 << bitpos(index);
|
|
u8 byte = data[bytepos(index)];
|
|
if constexpr (set)
|
|
byte |= mask;
|
|
else if constexpr (toggle)
|
|
byte ^= mask;
|
|
else if constexpr (clear)
|
|
byte &= ~mask;
|
|
data[bytepos(index)] = byte;
|
|
return byte & mask;
|
|
}
|
|
|
|
public:
|
|
/// @brief Create an empty bitmap
|
|
Bitmap() : linesize(0), lines(0) {}
|
|
|
|
/// @brief Create a new zero-filled bitmap
|
|
Bitmap(u32 width, u32 height)
|
|
{
|
|
resize(width, height);
|
|
}
|
|
|
|
inline u32 width() const { return linesize; }
|
|
inline u32 height() const { return lines; }
|
|
|
|
inline void resize(u32 width, u32 height, bool initial_value=false)
|
|
{
|
|
assert(width <= 65534 && height <= 65534); // index would overflow
|
|
linesize = width;
|
|
lines = height;
|
|
data.clear(); // make sure to discard all data
|
|
if (width && height)
|
|
data.resize(bytepos(width * height) + 1, static_cast<u8>(initial_value ? 0xff : 0));
|
|
}
|
|
|
|
inline void reset(bool value)
|
|
{
|
|
std::fill(data.begin(), data.end(), value ? 0xff : 0);
|
|
}
|
|
|
|
inline bool get(u32 x, u32 y) const
|
|
{
|
|
u32 index = y * linesize + x;
|
|
return data[bytepos(index)] & (1 << bitpos(index));
|
|
}
|
|
|
|
inline void set(u32 x, u32 y) { modify_<1, 0, 0>(x, y); }
|
|
inline void unset(u32 x, u32 y) { modify_<0, 0, 1>(x, y); }
|
|
inline bool toggle(u32 x, u32 y) { return modify_<0, 1, 0>(x, y); }
|
|
|
|
/// @brief Returns true if all bits in the bitmap are set
|
|
inline bool all() const
|
|
{
|
|
if (!linesize || !lines)
|
|
return (assert(0), true);
|
|
for (u32 i = 0; i < data.size() - 1; i++) {
|
|
if (data[i] != 0xff)
|
|
return false;
|
|
}
|
|
u8 last_byte = data.back(); // not used entirely
|
|
for (u8 i = 0; i < bitpos(linesize * lines); i++) {
|
|
if (!(last_byte & (1 << i)))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// Note: a 3D class could be written based on the 2D one. Or maybe the other way?
|