Extract bitmap class

src/util/bitmap.h

@@ -0,0 +1,93 @@
+// 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?