Fortaleza Romhack
Hola, Dark-N, tienes 1 mensaje, 0 son nuevos.
Tiempo total en línea: 21 horas y 26 minutos.
Mostrar mensajes no leídos desde la última visita.
Mostrar nuevas respuestas a tus mensajes.
12 de Septiembre de 2006, 12:48:59
Buscar:     Búsqueda Avanzada
       
2105 Mensajes en 296 Temas por 132 Usuarios
Último miembro: Dark-K
* Inicio Ayuda Buscar Editar Perfil Calendario Salir
+  Fortaleza Romhack
|-+  Foro de ayuda
| |-+  SNES (Moderadores: HeXPLuS, KaOSoFt)
| | |-+  entendiendo la carga de tiles con su formato
« anterior próximo »
Páginas: [1] Ir Abajo Respuesta Notificar respuestas Marcar como no leídos Enviar tema Imprimir
Autor Tema: entendiendo la carga de tiles con su formato  (Leído 127 veces)
Dark-N
Miembro Activo
**
Conectado Conectado

Mensajes: 81


naldo_go@hotmail.com
Ver Perfil WWW Email Mensaje Personal (Conectado)
entendiendo la carga de tiles con su formato
« en: 05 de Julio de 2006, 11:07:36 »
Responder con cita Modificar mensaje Eliminar mensaje

hay un muy buen documento txt en la secion Documento que habla sobre los distintos formatos de consolas. ¿alguen sabe en verdad como esa teoria de bipplanes, etc. se ve en la practica? Apuntense si quieren que les explique ya que tuve que entenderlo para un caso real de una rom que estoy viendo.
Reportar al moderador   200.54.71.227

Jhosemer
Miembro Activo
**
Desconectado Desconectado

Mensajes: 95

Miembro nuevo


Ver Perfil Email Mensaje Personal (Desconectado)
Re: entendiendo la carga de tiles con su formato
« Respuesta #1 en: 18 de Julio de 2006, 09:51:13 »
Responder con cita

Bueno pues yo me apunto. ¿Me lo explicas?
Reportar al moderador   En línea
Dark-N
Miembro Activo
**
Conectado Conectado

Mensajes: 81


naldo_go@hotmail.com
Ver Perfil WWW Email Mensaje Personal (Conectado)
Re: entendiendo la carga de tiles con su formato
« Respuesta #2 en: 14 de Agosto de 2006, 05:32:00 »
Responder con cita Modificar mensaje Eliminar mensaje

La Base

Partamos diciendo que una ROM = Datos + Código = archivo binario = conjunto de Bytes

Datos: datos que se utilizan en el juego como Tiles (comprimidas o no), sonidos, etc...
Código: código de ejecución, rutinas, subrutinas, cargas, saltos, LDAs, JPMs...

El Código hace uso de los Datos.
Tanto el Código como los Datos son solo de Lectura en el momento de la ejecución, no se escribe en ellos (ROM: read only memory). Ahora, que uno al hacer una edición uno pueda modificar esos bytes con un editor de Tiles o con un editor Hex, es otra cosa.

Por fuera de la ROM tenemos la RAM = Datos temporales. Se usa en tiempo de ejecución para almacenar solo DATOS TEMPORALES, como tiles que se descomprimen, variables temporales, etc.

Las Tiles están almacenadas en ROM inicialmente siempre. Pueden estar comprimidas o no, pero estan en ROM, en una dirección fija.

Como es la carga

La carga es el paso de la Tile de ROM a RAM o a VRAM.
La carga es a nivel de bytes, es decir se pasa byte a byte. No se puede pasar una Tile de una, en una sola instrucción, sino por bytes.
Cuantos colores tiene cierta Tile dependerá de la Paleta de colores que tenga.
Cuantos bytes conforman una tile dependerá de los Bitplanes de la Tile.

-Si la Paleta es de 1 bit, entonces la Tile puede tener como máximo 2 colores (1 bit puede tener 2 valores 1 o 0). Aquí la Tile es de 1 bitplane (1bpp=1bit per plane) por lo tanto está formada por 8 bytes.
-Si la Paleta es de 2 bits, entonces la Tile es de 4 colores (como el juego Mystical Ninja que traduzco), esto es porque 2 bit (00, 01, 10, 11 => 4 colores posibles). Aquí la tile es de 2 bitplanes, entonces la tile está formada por 16 bytes.
-Si la paleta es de 3 bits, 8 colores máximos posibles puede tener la Tile.
-Si la paleta es de 4 bits, 16 colores máximos posibles puede tener la Tile.
-Si la paleta es de 8 bits, 256 colores máximos posibles puede tener la Tile.

Entonces la ecuación es
Código:
Número colores máximo de Tile = 2^ (número bit paleta)

Ahora veamos como es la carga en el Mytical, para esto, debes ver el log que obtuve de ese momento:
http://www.nekein.com/tyh/temp/MysNinj0000.log

Aquí posiblemente no veas nada tangible, pero si miras con cuidado, verás estas cargas de bytes:

Código:
$00/9FE5 91 03       STA ($03),y[$7E:2010]   A:0000 X:0000 Y:0010 P:envMxdIZc
$00/A009 91 03       STA ($03),y[$7E:2011]   A:00FC X:0011 Y:0011 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2012]   A:0078 X:0012 Y:0012 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2013]   A:0086 X:0013 Y:0013 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2014]   A:0044 X:0014 Y:0014 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2015]   A:00BA X:0015 Y:0015 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2016]   A:0044 X:0016 Y:0016 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2017]   A:00BA X:0017 Y:0017 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2018]   A:0078 X:0018 Y:0018 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2019]   A:0086 X:0019 Y:0019 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201A]   A:0040 X:001A Y:001A P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201B]   A:00BC X:001B Y:001B P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201C]   A:0040 X:001C Y:001C P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201D]   A:00A0 X:001D Y:001D P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201E]   A:0000 X:001E Y:001E P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201F]   A:00E0 X:001F Y:001F P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2020]   A:0000 X:0020 Y:0020 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2021]   A:00E0 X:0021 Y:0021 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2022]   A:0040 X:0022 Y:0022 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2023]   A:00A0 X:0023 Y:0023 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:2024]   A:0040 X:0024 Y:0024 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:2025]   A:00A0 X:0025 Y:0025 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:2027]   A:00A0 X:0027 Y:0027 P:envMxdIzc
$00/A07C B1 03       LDA ($03),y[$7E:2026]   A:00A0 X:0028 Y:0026 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:2028]   A:0040 X:0028 Y:0028 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:2029]   A:00A0 X:0029 Y:0029 P:envMxdIzc
$00/A08A 91 03       STA ($03),y[$7E:202A]   A:0040 X:002A Y:002A P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:202B]   A:00BE X:002B Y:002B P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:202C]   A:007C X:002C Y:002C P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:202D]   A:0082 X:002D Y:002D P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:202E]   A:0000 X:002E Y:002E P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:202F]   A:00FE X:002F Y:002F P:envMxdIzc
...

¿Pero que es esto? Ya verás que significan.

Tiles y el documento gfxsnesgb

Mira las Tiles del Inicio del juego de Mystical Ninja y verás que son de 4 colores (haz un savestate del titulo con el ZSNES y mira ese ZST en el Tile Layer Pro), entonces se usa 2bpp = bitplane de 2 bit.

Si vemos el documento de gráficas de NES, SNES y GB llamado gfxsnesgb (traducido al español por Magimaster 2, revisado por KaOSoFt y Pablito's)
http://www.nekein.com/bdd/ -> Sección Documentos

Fijarse en la parte que dice:

Citar
-- Bitplane de 2 bits 8x8 --
4 colores, 16 bytes: Usado en muchos lugares en SNES y GB
...

Byte 0| Fila 0| Bpl 0|  00011000    0 /-- <=====Bitplane 0
     1|      0| Bpl 1|  00000000      | --\ 0 <=Bitplane 1
     2|      1|      0|  00111100   1 |-- |
     3|      1|      1|  00000000      | --| 1
     4|      2|      0|  01100110   2 |-- |
     5|      2|      1|  00000000      | --| 2
     6|      3|      0|  11000011   3 |-- |
     7|      3|      1|  00000000      | --| 3
     8|      4|      0|  11111111   4 |-- |
     9|      4|      1|  00000000      | --| 4
    10|      5|     0|  11000011   5 |-- |
    11|      5|     1|  00000000      | --| 5
    12|      6|     0|  11000011   6 |-- |
    13|      6|     1|  00000000      | --| 6
    14|      7|     0|  11000011    7 \-- |
    15|      7|     1|  00000000        --/ 7

A los que no se habían fijado, observen la ‘A’ como esta pintada.

Esto nos da un idea muy clara del asunto, como las Tiles de Mytical están dentro de este modo (son 2bpp), entonces la estructura de una tiles es así:
  Byte 0   , Byte 1   , Byte 2    , Bytes 3     , ......................., Byte 15
Bitplane 0, Bitplane 1, Bitplane 0, Bitplane 1, ......................., Bitplane 1

Entonces el total de una Tile en 2bpp es de 16 bytes.
Tomemos los primeras cargas de los 16 bytes de la lista de arriba:

Código:
$00/9FE5 91 03       STA ($03),y[$7E:2010]   A:0000 X:0000 Y:0010 P:envMxdIZc
$00/A009 91 03       STA ($03),y[$7E:2011]   A:00FC X:0011 Y:0011 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2012]   A:0078 X:0012 Y:0012 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2013]   A:0086 X:0013 Y:0013 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2014]   A:0044 X:0014 Y:0014 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2015]   A:00BA X:0015 Y:0015 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2016]   A:0044 X:0016 Y:0016 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2017]   A:00BA X:0017 Y:0017 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2018]   A:0078 X:0018 Y:0018 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:2019]   A:0086 X:0019 Y:0019 P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201A]   A:0040 X:001A Y:001A P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201B]   A:00BC X:001B Y:001B P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201C]   A:0040 X:001C Y:001C P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201D]   A:00A0 X:001D Y:001D P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201E]   A:0000 X:001E Y:001E P:envMxdIzc
$00/A009 91 03       STA ($03),y[$7E:201F]   A:00E0 X:001F Y:001F P:envMxdIzc

Si escribimos a lo largo los 16 bytes que se ven (son STA, fijarse entonces en el valor de A) tenemos:
00 FC 78 86 44 BA 44 BA 78 86 40 BC 40 A0 00 E0

Si los separamos según el documento, por Bitplanes, tenemos:

Bitplane 0
00
78
44
44
78
40
40
00

Bitplane 1
FC
86
BA
BA
86
BC
A0
E0

Pasemos el Bitplane 0 de Byte a bits:
00 = 0000000
78 = 1111000
44 = 1000100
44 = 1000100   => observa la tile ‘P’
78 = 1111000
40 = 1000000
40 = 1000000
00 = 0000000

Entonces el Bitplane 0 nos da la 'P'.

Si te cuesta ver la ‘P’, mírala con mi programa SNES Font Maker 1.0 (lo actualicé a SNES Font Simulator 1.1)


¿Y de que nos sirve le Bitplane 1?
El Bitplane 1 si lo vez de la misma forma, pasandola a binario, te dará el contorno de 'P':



Los bitplanes sirven para darle un efecto a la Tile, como profundidad o sombra.

Por último, la carga en este caso de ROM a RAM, ya que se hace un
STA ($03),y     -> dirección efectiva es $7E:201F (la entrega el LOG).

Y recuerda que $7E:XXXX y $7E:XXXX es área de RAM.

El porque se pasa la Tile de ROM a RAM, es porque está comprimida inicialmente en ROM. Pero eso es arina de otro costal. Ver Foro de Traducciones Magno (http://www.nekein.com/bdd/foro/index.php?topic=239.0)

EL segundo conjunto de 16 bytes es la Tile ‘L’. Analiza los bytes de la misma forma que la Tile ‘P’ para lograr verla.

Espero que haya quedado claro.  Roll Eyes
Reportar al moderador   200.54.71.227

Páginas: [1] Ir Arriba Respuesta Notificar respuestas Marcar como no leídos Enviar tema Imprimir 
« anterior próximo »
Eliminar Tema Bloquear tema
Ir a:  

Powered by MySQL Powered by PHP Fortaleza Romhack | Powered by SMF 1.0.7.
© 2001-2005, Lewis Media. Todos los Derechos Reservados.
XHTML 1.0 válido! CSS válido!