26 assert(bpp >= 1 && bpp <= 8);
27 unsigned int bpp_pos[8];
28 for (
int col = 0; col < 8; col++) {
29 for (
int row = 0; row < 8; row++) {
31 tile.
data[col * 8 + row] = (data[offset + col] >> (7 - row)) & 0x01;
38 bpp_pos[0] = offset + col * 2;
39 bpp_pos[1] = offset + col * 2 + 1;
40 char mask = 1 << (7 - row);
41 tile.
data[col * 8 + row] = (data[bpp_pos[0]] & mask) == mask;
42 tile.
data[col * 8 + row] |= ((data[bpp_pos[1]] & mask) == mask) << 1;
46 bpp_pos[2] = offset + 16 + col;
47 tile.
data[col * 8 + row] |= ((data[bpp_pos[2]] & mask) == mask) << 2;
52 bpp_pos[2] = offset + 16 + col * 2;
53 bpp_pos[3] = offset + 16 + col * 2 + 1;
54 tile.
data[col * 8 + row] |= ((data[bpp_pos[2]] & mask) == mask) << 2;
55 tile.
data[col * 8 + row] |= ((data[bpp_pos[3]] & mask) == mask) << 3;
58 bpp_pos[4] = offset + 32 + col * 2;
59 bpp_pos[5] = offset + 32 + col * 2 + 1;
60 bpp_pos[6] = offset + 48 + col * 2;
61 bpp_pos[7] = offset + 48 + col * 2 + 1;
62 tile.
data[col * 8 + row] |= ((data[bpp_pos[4]] & mask) == mask) << 4;
63 tile.
data[col * 8 + row] |= ((data[bpp_pos[5]] & mask) == mask) << 5;
64 tile.
data[col * 8 + row] |= ((data[bpp_pos[6]] & mask) == mask) << 6;
65 tile.
data[col * 8 + row] |= ((data[bpp_pos[7]] & mask) == mask) << 7;
74 std::vector<uint8_t> output(bpp * 8, 0);
75 unsigned maxcolor = 2 << bpp;
78 for (
unsigned int col = 0; col < 8; col++) {
79 for (
unsigned int row = 0; row < 8; row++) {
80 uint8_t color = tile.
data[col * 8 + row];
81 if (color > maxcolor) {
82 throw std::invalid_argument(
"Invalid color value.");
86 if (bpp == 1) output[col] += (uint8_t)((color & 1) << (7 - row));
90 output[col * 2] += ((color & 1) << (7 - row));
91 output[col * 2 + 1] += (((color & 2) == 2) << (7 - row));
95 if (bpp == 3) output[16 + col] += (((color & 4) == 4) << (7 - row));
99 output[16 + col * 2] += (((color & 4) == 4) << (7 - row));
100 output[16 + col * 2 + 1] += (((color & 8) == 8) << (7 - row));
105 output[32 + col * 2] += (((color & 16) == 16) << (7 - row));
106 output[32 + col * 2 + 1] += (((color & 32) == 32) << (7 - row));
107 output[48 + col * 2] += (((color & 64) == 64) << (7 - row));
108 output[48 + col * 2 + 1] += (((color & 128) == 128) << (7 - row));
115std::vector<uint8_t>
ConvertBpp(std::span<uint8_t> tiles, uint32_t from_bpp,
117 unsigned int nb_tile = tiles.size() / (from_bpp * 8);
118 std::vector<uint8_t> converted(nb_tile * to_bpp * 8);
120 for (
unsigned int i = 0; i < nb_tile; i++) {
122 std::vector<uint8_t> packed_tile =
PackBppTile(tile, to_bpp);
123 std::memcpy(converted.data() + i * to_bpp * 8, packed_tile.data(),
136 int buffer_size = 0x1000;
141 buffer_size = 0x2000;
142 }
else if (bpp == 3) {
144 }
else if (bpp == 4) {
146 buffer_size = 0x4000;
147 }
else if (bpp == 8) {
151 if (num_sheets != 1) {
152 num_tiles *= num_sheets;
153 buffer_size *= num_sheets;
156 std::vector<uint8_t> sheet_buffer_out(buffer_size);
158 for (
int i = 0; i < num_tiles; i++) {
159 for (
int y = 0; y < 8; y++) {
160 for (
int x = 0; x < 8; x++) {
171 if (b3 != 0 && bpp != 16) {
174 sheet_buffer_out[x + xx + (y * 128) + (yy * 1024)] = b;
186 return sheet_buffer_out;
202 auto buffer = std::vector<uint8_t>(data.size());
203 std::vector<std::vector<uint8_t>> bitmap_data;
204 bitmap_data.resize(0x80);
205 for (
auto& each : bitmap_data) {
212 const uint16_t sheet_width = 128;
218 for (
int i = 0; i < 4096; i++) {
220 for (
int y = 0; y < 8; y++) {
222 for (
int x = 0; x < 8; x++) {
223 const uint16_t bitmask[] = {0x80, 0x40, 0x20, 0x10,
224 0x08, 0x04, 0x02, 0x01};
225 auto b1 = (data[(y * 2) + ((bpp * 8) * pos)] & (bitmask[x]));
226 auto b2 = (data[((y * 2) + ((bpp * 8) * pos)) + 1] & (bitmask[x]));
227 auto b3 = (data[(y * 2) + ((bpp * 8) * pos) + 16] & (bitmask[x]));
228 auto b4 = (data[(y * 2) + ((bpp * 8) * pos) + 17] & (bitmask[x]));
229 auto b5 = (data[(y * 2) + ((bpp * 8) * pos) + 32] & (bitmask[x]));
230 auto b6 = (data[(y * 2) + ((bpp * 8) * pos) + 33] & (bitmask[x]));
231 auto b7 = (data[(y * 2) + ((bpp * 8) * pos) + 48] & (bitmask[x]));
232 auto b8 = (data[(y * 2) + ((bpp * 8) * pos) + 49] & (bitmask[x]));
264 bitmap_data[x + xx][y + (yy * 8)] = b;
279 for (
int y = 0; y < (data.size() / 64); y++) {
280 for (
int x = 0; x < sheet_width; x++) {
281 if (n < data.size()) {
283 buffer[n] = bitmap_data[x][y];
310 uint16_t
id = word & 0x3FF;
313 bool vertical_mirror = (word >> 15) & 0x01;
314 bool horizontal_mirror = (word >> 14) & 0x01;
315 bool over = (word >> 13) & 0x01;
318 uint8_t palette = (word >> 10) & 0x07;
320 return TileInfo(
id, palette, vertical_mirror, horizontal_mirror, over);
367 std::vector<uint8_t>& blockset) {
369 ((tile - ((tile / 0x08) * 0x08)) * 0x10) + ((tile / 0x08) * 2048);
370 int dest_pos = (x + (y * 0x200));
371 for (
int yy = 0; yy < 0x10; yy++) {
372 for (
int xx = 0; xx < 0x10; xx++) {
373 bitmap[dest_pos + xx + (yy * 0x200)] =
374 blockset[src_pos + xx + (yy * 0x80)];
380 std::span<uint8_t> src) {
381 std::vector<uint8_t> dest;
393 int main_index_limit = src.size() / 32;
394 for (
int main_index = 0; main_index <= main_index_limit; main_index += 32) {
395 src_index = (main_index << 5);
396 if (src_index + 31 >= src.size()) {
397 throw std::invalid_argument(
"src_index + 31 >= src.size()");
399 dest_x = main_index & 0x0F;
400 dest_y = main_index >> 4;
401 dest_index = ((dest_y << 7) + dest_x) << 3;
402 if (dest_index + 903 >= dest.size()) {
403 throw std::invalid_argument(
"dest_index + 903 >= dest.size()");
405 for (
int i = 0; i < 16; i += 2) {
407 b0 = src[src_index + i];
408 b1 = src[src_index + i + 1];
409 b2 = src[src_index + i + 16];
410 b3 = src[src_index + i + 17];
411 for (
int j = 0; j < 8; j++) {
412 res = ((b0 & mul) | ((b1 & mul) << 1) | ((b2 & mul) << 2) |
413 ((b3 & mul) << 3)) >>
415 dest[dest_index + (7 - j) + y_adder] = res;