Решил разобраться с алгоритмами более подробно.

С 1bpp кое-как разобрался.



Всё не очень сложно. Информация тайла кодируется 8 байтами. Каждый байт - это строка, получается 8 строк. Переводим из шестнадцатеричной системы счисления в двоичную, 0 - нет точки, 1 - есть точка.

И рисовать не очень сложно:

1. Читаем символ из рома в hex виде: Read (File, B)
2. Переводим его в бинарный вид: inttoBin(B)
3. Так делаем 8 раз и получаем 64 символа из нулей и единичек
4. Рисуем точку или нет, двигаясь по всей считанной информации на поле 8х8 точек.

А вот уже с 2bpp я вообще не пойму никак алгоритм... Там получается не 0 и 1, а уже 4 цвета (прозрачный цвет и 1, 2, 3). Как описать алгоритм по пунктам?

Все мои редакторы используют вместо графики из рома заранее подготовленные картинки, что не есть гуд. Хотелось бы понять как вывести графику прямо из рома.

Здесь можешь почитать пояснения к форматам https://github.com/shonumi/Emu-D...m/consolegfx.txt


2 bpp хранятся по-разному, в зависимости от консоли.
Для nes, например, биты одного пикселя разнесены по разным байтам.
Если например первый бит хранится в первом байте, то второй в восьмом.
Таким образом для первой строки пикселей младшие биты хранятся в первом байте, а старшие биты в восьмом байте.



Здесь в квадратных скобках это один байт, всего здесь 16 байт.
r0 - означает строка пикселей под индексом 0. Всего 8 строк. bp1 битовый план 1, bp2, соответственно, битовый план 2. Битовые планы - это младшие и старшие биты пикселя.
Таким образом, мы видим, что в первом байте [r0, bp1], первая строка пикселей с младшими битами, а в восьмом байте [r0, bp2], первая строка пикселей со старшими битами. Во втором байте [r1, bp1], вторая строка пикселей с младшими битами, а в девятом [r1, bp2] вторая строка пикселей со старшими битами и т.д.

Ну хорошо, взял для примера и нарисовал это:



1 линия: 00 00
2 линия: FF 00
3 линия: 00 FF
4 линия: FF FF
5 линия: 00 00
6 линия: C0 00
7 линия: 00 30
8 линия: 0C 0C

Но вот почему вторая линия FF 00 я пока не могу понять. Марат, распиши порядок действия, который приводит к такому результату...

Это так получается?

Вторая линия:
0 цвет 0000 0000
1 цвет 1111 1111 - FF
2 цвет 0000 0000
3 цвет 0000 0000

Восьмая линия:
0 цвет 0000 1100 - 0C ?
1 цвет 0000 0000
2 цвет 0000 0000
3 цвет 0000 1100 - 0C

Как в восьмой линии получилось ещё одно 0C? Там число инвертируется?

П.С. Не так?

1 план - 2 цвета. Чёрный и оранжевый.
Черный цвет есть - 0, нет - 1
Оранжевый цвет есть - 1, нет - 0

2 план - 2 цвета. Розовый и белый.
Розовый цвет есть - 0, нет - 1
Белый цвет есть - 1, нет - 0

8 линия:
1 план:
ЧЧЧЧххЧЧ
00001100 - 0C
2 план:
ххххББхх
00001100 - 0C

1 план:
ОЧхх хЧОх
черный
0100 0100
оранжевый
1000 0010
итог
1100 0110 - ?
1001 1010 - 9A должно получиться...

2 план:
ххКБ БххК

красный
0010 0001
белый
0001 1000
итог
0011 1001 - 39


Я явно что-то недопонимаю...

Теперь вроде получается:



1 план:
черный или розовый - 0, оранжевый или белый - 1
1110 1011 - EB

2 план
розовый или белый - 1, чёрный или оранжевый - 0
10001111 - 8F

Пробуем в обратную сторону:



1 план:
EB: 1110 1011 - О/Б О/Б О/Б Ч/Р О/Б Ч/Р О/Б О/Б

2 план
8F: 1000 1111 - Р/Б Ч/О Ч/О Ч/О Р/Б Р/Б Р/Б Р/Б

О/Б и Р/Б дают в итоге белый и т.д.

О/Б О/Б О/Б Ч/Р О/Б Ч/Р О/Б О/Б
Р/Б Ч/О Ч/О Ч/О Р/Б Р/Б Р/Б Р/Б
Итого:
Б О О Ч Б Р Б Б

Вроде бы понятно как всё организовано. Осталось облечь это в какую-то форму математическую ;о)

Получается:
0 0 - чёрный (0 цвет)
1 0 - оранжевый (1 цвет)
0 1 - розовый (2 цвет)
1 1 - белый (3 цвет)

Просто берёшь по одному биту с каждого плана и у тебя получается индекс нужного цвета. Биты читаются слева направо от старшего к младшему. Таким образом, первый цвет 11, второй 01, третий 01, четвертый 00, пятый 11, шестой 10 и т.д.

Получилось для NES, SNES/Gameboy/GBC 2bpp и SNES 3bpp:



Для 4bpp пока не могу понять...

Да там плюс минус так же

А чем 3bppSNES от 3bpp отличается?

П.С. Всё, понял чем:



С 4bpp тоже всё понятно...

Интересная статья на эту тему.
Хранение несжатой графики на различных игровых системах
http://pscd.ru/forum/index.php?/...lichnykh-igrovy/

http://pscd.ru/forum/index.php?/...oi-grafiki-1bbp/

ZetpeR, по этим руководствам мне всё же много непонятного. 1bpp расписан хорошо, а вот для GBA я так и не пойму алгоритм по описанию...

4 bpp gba это тот же линейный 4 битный формат, как на Sega genesis только соседние 4 бита поменяны местами. Т.е., если на сеге xxxx yyyy, то на gba yyyy xxxx.

Хорошо, а сега тогда как считается? Мне осталось освоить сегу и гба, но пока что-то не получается алгоритм повторить...

Сега:

[p1-2 r0: bp*], [p2-3 r0: bp*], [p4-5 r1: bp*], [p6-7 r1: bp*]
[p1-2 r2: bp*], [p2-3 r2: bp*], [p4-5 r3: bp*], [p6-7 r3: bp*]
[p1-2 r4: bp*], [p2-3 r4: bp*], [p4-5 r5: bp*], [p6-7 r5: bp*]
[p1-2 r6: bp*], [p2-3 r6: bp*], [p4-5 r7: bp*], [p6-7 r7: bp*]

Что это за звёздочки? В других алгоритмах всё понятно:

[r0, bp1], [r0, bp2], [r0, bp3], [r0, bp4], [r1, bp1], [r1, bp2], [r1, bp3], [r1, bp4]
[r2, bp1], [r2, bp2], [r2, bp3], [r2, bp4], [r3, bp1], [r3, bp2], [r3, bp3], [r3, bp4]
[r4, bp1], [r4, bp2], [r4, bp3], [r4, bp4], [r5, bp1], [r5, bp2], [r5, bp3], [r5, bp4]
[r6, bp1], [r6, bp2], [r6, bp3], [r6, bp4], [r7, bp1], [r7, bp2], [r7, bp3], [r7, bp4]

А тут?

В каждом байте по два пикселя. Пиксели читаются слева направо, если не ошибаюсь. Берём байт сдвигаем вправо на 4 бита это первый пиксель. Оставшиеся 4 бита это второй пиксель.

Pixel_1 := (data[i] shr 4) and $0f
Pixel_2 := data[i] and $0f
И так далее

Мне кажется там ошибка в описании. И если следовать описанию формата, то должно быть так

Ещё хотел спросить, я прочитал из файла байт:

var
F: File of Byte;
A1: Byte;
...
...
Read(F, A1);

dec2hex(A1) допустим равно AF

Как мне перевернуть байт? Т.е. вместо прочитанного AF получить FA? Есть такая функция, которая в делфи у однобайтного числа меняет старшую и младшую часть местами? Swap подходит к двухбайтным числам вида FF98, а у меня однобайтное сисло...

Нет таких функций в Дельфи. Минимальная единица - байт. Сдвигами надо менять местами тетрады.

Ясно. Ну да ладно, использовал типовую функцию ReverseString и отреверсил считанные байты...

A1 := (A1 shr 4) or ((A1 and $F) shl 4);
Так, по-моему, самое простое решение.
А манипуляции со строками это не самое эффективное решение.
Да и медленное, потому что связано с выделением памяти.

Спасибки!