Ver la versión completa : ¿Qué tipo de números son éstos?
Haohmaru
16/12/2012, 01:33
Buenas a todos, ¿Alguien sabe viendo este ejemplo de datos que pongo, qué tipo de números son?
Esto, es la conversión el contenido de un fichero de Tiles , para importarlo luego en código C, donde consta en este ejemplo, de 24 tiles.
{0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000},
{0xaa80, 0x0800, 0x4854, 0x1555, 0x1555, 0x4854, 0x0800, 0xaa80},
{0x0140, 0x0550, 0x0550, 0x8552, 0x8142, 0xa96a, 0x8142, 0x8412}
Mi fin es entender que transformación de datos se hacen para intentar realizar un aplicación que haga lo mismo que esta (trasnformar imágenes (tiles) a un fichero con estas numeraciones) porque dicha aplicació es muy aracica.
Gracias.
Son números hexadecimales, concretamente enteros de 16 bits. Tendrías que ver qué tamaño (ancho y alto) y profundidad del color tienen las imágenes (bits por pixel) y si tienen paleta o son color directo para intentar averiguar el formato. Si me dices que esos números que has puesto son 24 tiles, yo diría que son tiles en blanco y negro de 4x4 y los números en binario representan líneas de pixels con ceros y unos.
Haohmaru
16/12/2012, 13:40
Buenas hardyx, gracias por tu respuesta.
La verdad es que casi has dado en el clavo. Son tiles de 8x8 y a color, con una paleta de 3 colores por tile (con un 4º que es el negro como transparencia) ¿Sabrías orientarme un poco para saber que tipo de datos tendría que saber en este caso para realizar la conversión?
Sin mas datos de ejemplo es complicado.
Salen 24 numeros de 16 bits, igual que los tiles, y si dices que los tiles llevan paleta, lo mas seguro es que usen un byte para la paleta/efectos de espejo, prioridad... y el otro para el indice del tile.
Si puedes haz pruebas haciendo una mapa con todos los tiles iguales, otro solo con un tile distinto, etc y mira los resultados.
Segata Sanshiro
16/12/2012, 15:34
Deseas convertir una imagen en formato bmp, png o lo que sea, al formato hexadecimal ése, ¿no?
Necesitaríamos saber qué es lo que haces luego con esos datos en hexadecimal (a qué función se los pasas, o en que parte de la memoria los pones...). En cualquier caso, debe estar en el formato gráfico de la NGPC (si es que es el sistema para el que estás trabajando, me suena haberlo leído en otro hilo). Pero ojo, porque en NGPC cada tile ocupa 16 bytes (sin contar la paleta), osea que en ese array que pones solo habría 3 tiles.
Perdón si la explicación es un poco liosa xD Si no he sido claro dilo.
Haohmaru
16/12/2012, 15:35
Deseas convertir una imagen en formato bmp, png o lo que sea, al formato hexadecimal ése, ¿no?
Necesitaríamos saber qué es lo que haces luego con esos datos en hexadecimal (a qué función se los pasas, o en que parte de la memoria los pones...). En cualquier caso, debe estar en el formato gráfico de la NGPC (si es que es el sistema para el que estás trabajando, me suena haberlo leído en otro hilo). Pero ojo, porque en NGPC cada tile ocupa 16 bytes (sin contar la paleta), osea que en ese array que pones solo habría 3 tiles.
Perdón si la explicación es un poco liosa xD Si no he sido claro dilo.
Si Segata, es para la Neo Geo Pocket :) Ando haciendo un juego. Os dejo a todos algo más de información a ver si llego a un entendimiento xD
Lo que puedo comentar es que pasos doy para obtener esto y donde lo aplico, quizás así os sirva.
A ver, hay un programa para crear tiles, llamado NeoTile, que me permite añadir tiles de 8x8 y con una paleta de colores, el resultado, cuando le indico al NeoTile que exporte el fichero, genera un fichero .c, donde, por cada tile de 8x8, contiene un array de 8 elementos, donde cada elemento es un color, y por lo que entiendo, los colores restantes no usados se representan con el negro como transparencia (0x0000).
Por ejemplo, éste fichero es de una transformación de 3 tiles, cada uno de 3 colores, en este caso, 2 tonalidades de azul y 1 de azul un poco más flojo:
Azul fuerte: 0x02aa
Azul flojo: 0x0155
Negro: 0x0000
const unsigned short barra_azul[3][8] =
{
{0x0000, 0x02aa, 0x0155, 0x02aa, 0x0000, 0x0000, 0x0000, 0x0000}, // C1xR1
{0x0000, 0xaaaa, 0x5555, 0xaaaa, 0x0000, 0x0000, 0x0000, 0x0000}, // C2xR1
{0x0000, 0xaa80, 0x5540, 0xaa80, 0x0000, 0x0000, 0x0000, 0x0000} // C3xR1
};
Lo que realmente me interesa es como transformar un color X a ese sistema de numeración, ya sea a través de programación o lo que sea.
Para mi que lo que muestras es el bitmap de cada tile, como son de 8x8 pixels con 4 colores = 2bits por pixel, cada fila ocupa un entero de 16bits (2 bytes).
¿Solo guarda eso? En algun otro lado debe guardar la paleta, para saber que color en rgb debe usar para cada color/indice en el tile.
Haohmaru
16/12/2012, 16:06
Para mi que lo que muestras es el bitmap de cada tile, como son de 8x8 pixels con 4 colores = 2bits por pixel, cada fila ocupa un entero de 16bits (2 bytes).
¿Solo guarda eso? En algun otro lado debe guardar la paleta, para saber que color en rgb debe usar para cada color/indice en el tile.
Pues no, solo se guarda eso :$ yo no tengo nada más. Luego incluyo el fichero en el desarrollo y aplico los tiles simplemente por posición, no indico colores.
Segata Sanshiro
16/12/2012, 16:16
Hmm se nos escapa algo, porque en principio ahí no están los datos de la paleta. ¿Se ven correctamente los tiles cuando ejecutas el programa?
No se... prueba a hacer dibujar el mismo tile pero en verde o rojo a ver que te exporta, en alguna parte debe guardar la paleta que usa, por cierto dices que genera un fichero.c, ¿no genera tambien un fichero.h? puede que ahi este la paleta a usar.
Haohmaru
16/12/2012, 16:27
Hmm se nos escapa algo, porque en principio ahí no están los datos de la paleta. ¿Se ven correctamente los tiles cuando ejecutas el programa?
No se... prueba a hacer dibujar el mismo tile pero en verde o rojo a ver que te exporta, en alguna parte debe guardar la paleta que usa, por cierto dices que genera un fichero.c, ¿no genera tambien un fichero.h? puede que ahi este la paleta a usar.
Antes de nada daros las gracias por las molestias que os estáis tomando.
Pues si y no, tengo que utilizar otra función llamada SetColors(), para crear paletas de colores, que son los colores que se aplicarán por capa para los tiles, si no creo las paletas de colores no se ve nada, ejemplo:
Utilizando el ejemplo de antes, de 3 colores, 2 azules fuerte y uno flojo, tendría que hacer lo siguiente:
SetColors(PLANO_DE_PANTALLA, Nº de Paleta, RGB(x,x,x), RGB(x,x,x), RGB(x,x,x) )
Donde cada RGB(x,x,x) indicaría uno de los colores que voy a crear en la peleta que van a usar los tiles importados.
Posteriormente insertaría los tiles, indicando que paleta van a usar:
PutTile(PLANO_DE_PANTALLA, Nº de Paleta, pos_x, pos_y, nº de tile)
Pues entonces ya esta claro como va, yo pensaba que las paletas las guardaba en otro fichero pero al parecer las tienes que meter "hard-coded" a no ser de que las puedas exportar en un fichero, las cargues y las metas con la función SetColors.
Lo que hace el hardware para mostrar los pixels es lo siguiente, lee los pixels de un tile, ej:
00112233 donde cada numero indica un color o indice.
Lee el numero de paleta que le corresponde por ejemplo la paleta 5.
Busca en la paleta de colores el color en rgb haciendo: numero de paleta * 4 (colores por tile) + pixel del tile. En este caso seria 5*4+0 para el primer y segundo pixel, 5*4+1 para el tercero y cuarto...
Espero que se entienda.
Segata Sanshiro
16/12/2012, 16:41
Vale, ahí está la clave, supongo que la función SetColors ya se encargará de guardar en la zona de memoria adecuada los datos de la paleta.
En un documento venía esta nota sobre el formato de los tiles para la NGPC:
1 tile = 8 x 8 pixels (= 16 bytes)
4 pixels @ 2BPP = 1 byte (Pixel:Bit ordering: 10 32 54 76)
Por ejemplo, cogiendo el byte 3 del primer tile que pones (el "02" de "0x02aa"), en binario es: 0000 0010, lo cual representa 4 píxeles con los colores 0, 0, 0 y 1 de la paleta.
Igual me he colado al interpretarlo, pero en el fondo NO importa de qué color sea cada píxel ni la forma rara de ordenar los píxeles que aparece en el documento, sino que solo importa que píxeles de colores distintos tengan códigos de 2 bits distintos. Luego ya pondrás la paleta adecuada para que el color RGB de cada píxel del tile sea el adecuado.
Haohmaru
17/12/2012, 00:16
Vale, ahí está la clave, supongo que la función SetColors ya se encargará de guardar en la zona de memoria adecuada los datos de la paleta.
En un documento venía esta nota sobre el formato de los tiles para la NGPC:
1 tile = 8 x 8 pixels (= 16 bytes)
4 pixels @ 2BPP = 1 byte (Pixel:Bit ordering: 10 32 54 76)
Por ejemplo, cogiendo el byte 3 del primer tile que pones (el "02" de "0x02aa"), en binario es: 0000 0010, lo cual representa 4 píxeles con los colores 0, 0, 0 y 1 de la paleta.
Igual me he colado al interpretarlo, pero en el fondo NO importa de qué color sea cada píxel ni la forma rara de ordenar los píxeles que aparece en el documento, sino que solo importa que píxeles de colores distintos tengan códigos de 2 bits distintos. Luego ya pondrás la paleta adecuada para que el color RGB de cada píxel del tile sea el adecuado.
Ostias, he leído varias veces lo que has escrito pero no lo entiendo muy bien. Voy a necesitar extender mis conocimientos en numeración binaria y hexadecimal, que ya no me acuerdo de eso.
Segata Sanshiro
17/12/2012, 00:28
Es sencillo, lo que pasa es que me he explicado como el culo xD Si saco algo de tiempo pondré algún ejemplo.
Haohmaru
17/12/2012, 00:58
Es sencillo, lo que pasa es que me he explicado como el culo xD Si saco algo de tiempo pondré algún ejemplo.
Pues muchísimas gracias Segata :D es todo un detalle
Por ejemplo, cogiendo el byte 3 del primer tile que pones (el "02" de "0x02aa"), en binario es: 0000 0010, lo cual representa 4 píxeles con los colores 0, 0, 0 y 1 de la paleta.
Has metido la pata, es el color 2 de la paleta.
0x02aa = %00 00 00 10 10 10 10 10 -> color 0 0 0 2 2 2 2, estos colores se usan como un indice entro de la paleta asociada al tile (la que pones con SetColors)
Segata Sanshiro
17/12/2012, 02:00
Si lo que pone en el documento técnico es correcto (no es un documento oficial), el orden de los bits está invertido dentro de cada pareja de bits, así que 10 sería el color 1 y no el 2.
En cualquier caso esto solo influye a la hora de asignar los valores RGB definitivos, no a la forma del dibujo.
Haohmaru
18/12/2012, 00:17
La verdad es que esto se me está volviendo un poco pesado, me pierdo en ciertos aspectos.
Si no he entendido mal, se supone que esto sería algo así en pasos (por decirlo de alguna manera):
Tile >> Obtención de valores hexadecimales >> Transformación de valor Hexadecimal a Hexadecima lde 16 bits
Entiendo que, de alguna manera que ya intentaré averiguar como, se obtiene los bytes del Tile, y de ésto, se obtiene su valor hexadecimal, posteriormente, se transforman a dígitos hexadecimales de 16 bits ¿Estoy equivocado?
Si tienes acceso a la memoria donde estan los tiles, si en vez de acceder a ellos por un puntero a byte(char en C) usas un puntero a short ya lo tienes hecho, despues haces un fprintf(out, "%04x", *ptr) y ya esta. Donde ptr es el puntero a la memoria de los tiles.
Haohmaru
18/12/2012, 13:50
Si tienes acceso a la memoria donde estan los tiles, si en vez de acceder a ellos por un puntero a byte(char en C) usas un puntero a short ya lo tienes hecho, despues haces un fprintf(out, "%04x", *ptr) y ya esta. Donde ptr es el puntero a la memoria de los tiles.
Me perdí por completo. Creo que lo que explicas es el proceso contrario de lo que quiero hacer. Mi fin es el siguiente:
El programa para crear Tiles es una auténtica caca, pero, es el único que hay. Lo que pretendo es saber que proceso o como haría el proceso para convertir los tiles que le paso a un fichero con extención .c, con el sistema numérico que puse en el primer post.
Segata Sanshiro
18/12/2012, 14:51
Lo que dice swapd0 te sirve para cuando tengas cargados los tiles ya en memoria, y seguramente sea la forma más rápida de hacerlo una vez los tengas ya cargados.
Para ir un poco por partes, una de las muchas formas de hacerlo sería:
- Dibujar el tile en GIMP, Photoshop, etc. y guardarlo en un formato que sea muy sencillo de leer, como por ejemplo PGM. Asegúrate de que el programa te deja elegir guardarlo en formato PGM "ASCII", para facilitar las cosas. Aquí tienes los detalles del formato PGM: http://paulbourke.net/dataformats/ppm/
- Crear una utilidad en C, Java, etc. que lea el fichero PGM y escriba un fichero .c (o al menos un fichero de texto con el array en el formato de C, para copiarlo y pegarlo en tu código).
Para ir probando, puedes hacer un dibujo de 16x16 en escala de grises, guardarlo en PGM, y abrirlo con un editor de texto, para ver cómo es. Aquí tienes detallado el formato. Básicamente te encontrarás:
- Una línea con la cabecera "P2"
- Opcionalmente, una línea con un comentario introducido por el editor gráfico que hayas usado
- Una línea con dos números separados por un espacio, que son las dimensiones del gráfico
- Una línea que dice el valor máximo que puede tomar cada píxel. Seguramente sea 255 o 15 o algo así, donde 255 es blanco y 0 es negro. Realmente solo necesitamos 4 tonos de gris, si consigues configurar tu editor gráfico para que trabaje directamente a 4 tonos de gris mejor (en ese caso en esta línea pondrá un "3"). Más tarde asignarás en tu programa la paleta con los valores RGB que quieras.
- Un montón de líneas, ya con los valores de cada píxel. Asegúrate de que lo has pintado de forma que solo aparezcan valores de 0 a 3 en estas líneas.
La utilidad que crees debe ir leyendo esas últimas líneas (las de los valores de los píxeles), por ejemplo con la función readLine de un BufferedReader en Java. Debes tomar las líneas de ocho en ocho y "empaquetarlas" en variables 16 bits (esto es lo que hay que hacer con cuidado para que quede bien xD), y luego usar alguna función (dechex, printf...) que imprima dichas variables en formato 0xABCD.
Seguramente haya formas más sencillas y rápidas pero es lo primero que se me ha ocurrido xD Aunque no quede claro del todo, ¿sabes al menos ya por dónde empezar?.
Haohmaru
18/12/2012, 18:15
Pues la verdad es que no lo tengo nada claro. Lo que comenta swapd0 sigo sin entender el sentido de para que usarlo.
La parte que me explicas para trabajar con la imagen pues, si no me queda otra que eso lo mirare con profundidad porque asi con unas líneas no es fácil de entender, aunque gracias.
He encontrado un conversor de tiles de GB a NGP, el conversor no me funciona no hace un carajo pero, trae consigo un fichero .c donde hay métodos y tal. He intentado comprender un poco lo que hace pero creo que faltan ficheros, ya que los include no están en el directorio
A ver si alguno tiene ganas y le hecha un ojete (https://dl.dropbox.com/u/3877624/GB2NGP.rar)"
Circunstante
18/12/2012, 19:54
Los primeros son octillizos, los siguientes tienen pinta de ser gemelos de distintos padres, y hay uno que a mi me da que es un primo. Lo que esta claro es que son todos de origen persa con rasgos latinos.
Santo cielo, ¡qué pregunta!
Te comento la primera funcion
// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
int i, j, c1, c2;
unsigned int val;
int clr;
for (i=0; i < filesize; i+=2)
{
// handle 2 bytes at a time
c1 = getc(fpi); // byte alto de la palabra de 16bits
c2 = getc(fpi); // byte bajo
val = 0; // valor de salida
// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567 01234567
// || ||
// |--------- |-- color del segundo pixel
// | |
// -------------- color del primer pixel
for (j=0; j<8; j++)
{
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
if (c1 & 0x80) clr=1; else clr=0;
if (c2 & 0x80) clr+=2;
// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
val <<= 2;
val +=clr;
// desplazo los bytes de entrada un pixel/bit hacia la izquierda
c1 <<= 1;
c2 <<= 1;
}
// guardo el valor generado
putc(val & 0xff, fpo); // parte alta
putc(val >> 8, fpo); // parte baja
}
}
-----Actualizado-----
Te comento la primera funcion
// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
int i, j, c1, c2;
unsigned int val;
int clr;
for (i=0; i < filesize; i+=2)
{
// handle 2 bytes at a time
c1 = getc(fpi); // byte alto de la palabra de 16bits
c2 = getc(fpi); // byte bajo
val = 0; // valor de salida
// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567 01234567
// || ||
// |--------- |-- color del segundo pixel
// | |
// -------------- color del primer pixel
for (j=0; j<8; j++)
{
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
if (c1 & 0x80) clr=1; else clr=0;
if (c2 & 0x80) clr+=2;
// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
val <<= 2;
val +=clr;
// desplazo los bytes de entrada un pixel/bit hacia la izquierda
c1 <<= 1;
c2 <<= 1;
}
// guardo el valor generado
putc(val & 0xff, fpo); // parte alta
putc(val >> 8, fpo); // parte baja
}
}
-----Actualizado-----
// neogeo pocket to gameboy
void ngp2gb (FILE *fpi,
FILE *fpo,
int filesize)
{
int i, j, c1, c2;
unsigned int val = 0;
int clr;
int out1;
int out2;
for (i=0; i < filesize; i+=2)
{
// leo 2 bytes y los uno en un entero de 16 bits (ok la variable es de 32 pero no importa)
c1 = getc(fpi);
c2 = getc(fpi);
val = ((c2 & 0xff) <<8) + (c1 & 0xff);
// inicializo la salida a 0
out1 = 0;
out2 = 0;
for (j=0; j<8; j++)
{
// me quedo con los 2 bits mas altos desplazandolos a la parte baja
// xx000000 00000000 -> 00000000 000000xx
clr = val >> 14;
// desplazo los valores de entrada 2 bits hacia la izquierda para la siguente iteracion del bucle
val <<= 2;
// lo mismo pero con la salida, despues de esto el bit mas bajo de out1 y out2 estan a 0
out1 <<= 1;
out2 <<= 1;
// si el bit mas bajo esta a uno, pongo el bit mas bajo de out1 a uno
if (clr & 1) out1++;
// si el segundo bit mas bajo esta a uno, pongo el bit mas bajo de out2 a uno
if (clr & 2) out2++;
// con esto he pasado he hecho lo siguiente, donde a y b representan un pixel con 4 posibles colores
// 00000000 000000ab -> 0000000b 0000000a
}
// vuelca los valores al fichero
putc(out1, fpo);
putc(out2, fpo);
}
}
Otra opción es que hagas los gráficos en gimp (asegúrate que está en modo indexado y máximo 4 colores) y lo guardas como .h ó .c. Ahora haces un pequeño programita que transforme de los arrays de salida de Gimp al tipo que quiere la NGC. Este programita los gurús de C de aquí lo harán en medio minuto. Por ejemplo:
int main(int argc, char ** argv) {
int i;
int c=0;
for(i=0; i<64; i++) c += (i * 4 + header_data[i]);
printf("0x%0x\n", c);
}
Y esto lo tienes que hacer para cada tile. Como ejemplo, con este programita este dibujo en Gimp
29947
Dice que se codifica como 0x2011
(ahora toca saber exactamente qué bits son columnas y filas y colores, pero eso es solo retocar los números)
-----Actualizado-----
(Buf, me he liado mucho y no estoy nada seguro de lo que he dicho...)
Haohmaru
18/12/2012, 21:50
Te comento la primera funcion
// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
int i, j, c1, c2;
unsigned int val;
int clr;
for (i=0; i < filesize; i+=2)
{
// handle 2 bytes at a time
c1 = getc(fpi); // byte alto de la palabra de 16bits
c2 = getc(fpi); // byte bajo
val = 0; // valor de salida
// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567 01234567
// || ||
// |--------- |-- color del segundo pixel
// | |
// -------------- color del primer pixel
for (j=0; j<8; j++)
{
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
if (c1 & 0x80) clr=1; else clr=0;
if (c2 & 0x80) clr+=2;
// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
val <<= 2;
val +=clr;
// desplazo los bytes de entrada un pixel/bit hacia la izquierda
c1 <<= 1;
c2 <<= 1;
}
// guardo el valor generado
putc(val & 0xff, fpo); // parte alta
putc(val >> 8, fpo); // parte baja
}
}
-----Actualizado-----
Te comento la primera funcion
// gameboy to neogeo pocket// fpi fichero de entrada
// fpo fichero de salida
// filesize ... pues el tamaño de entrada
void gb2ngp (FILE *fpi, FILE *fpo, int filesize)
{
int i, j, c1, c2;
unsigned int val;
int clr;
for (i=0; i < filesize; i+=2)
{
// handle 2 bytes at a time
c1 = getc(fpi); // byte alto de la palabra de 16bits
c2 = getc(fpi); // byte bajo
val = 0; // valor de salida
// parace que la gameboy tiene los colores entrelazados o por planos
// 8 pixels = 2 bytes
// byte alto byte bajo
// 01234567 01234567
// || ||
// |--------- |-- color del segundo pixel
// | |
// -------------- color del primer pixel
for (j=0; j<8; j++)
{
// miro el bit mas alto de cada byte y lo convierto a un valor
// "empaquetado" con los bits contiguos
if (c1 & 0x80) clr=1; else clr=0;
if (c2 & 0x80) clr+=2;
// desplazo el valor de salida hacia la izquierda y le añado el
// valor del color "empaquetado"
// yo lo veo mas claro asi val = (val << 2) | clr;
val <<= 2;
val +=clr;
// desplazo los bytes de entrada un pixel/bit hacia la izquierda
c1 <<= 1;
c2 <<= 1;
}
// guardo el valor generado
putc(val & 0xff, fpo); // parte alta
putc(val >> 8, fpo); // parte baja
}
}
-----Actualizado-----
// neogeo pocket to gameboy
void ngp2gb (FILE *fpi,
FILE *fpo,
int filesize)
{
int i, j, c1, c2;
unsigned int val = 0;
int clr;
int out1;
int out2;
for (i=0; i < filesize; i+=2)
{
// leo 2 bytes y los uno en un entero de 16 bits (ok la variable es de 32 pero no importa)
c1 = getc(fpi);
c2 = getc(fpi);
val = ((c2 & 0xff) <<8) + (c1 & 0xff);
// inicializo la salida a 0
out1 = 0;
out2 = 0;
for (j=0; j<8; j++)
{
// me quedo con los 2 bits mas altos desplazandolos a la parte baja
// xx000000 00000000 -> 00000000 000000xx
clr = val >> 14;
// desplazo los valores de entrada 2 bits hacia la izquierda para la siguente iteracion del bucle
val <<= 2;
// lo mismo pero con la salida, despues de esto el bit mas bajo de out1 y out2 estan a 0
out1 <<= 1;
out2 <<= 1;
// si el bit mas bajo esta a uno, pongo el bit mas bajo de out1 a uno
if (clr & 1) out1++;
// si el segundo bit mas bajo esta a uno, pongo el bit mas bajo de out2 a uno
if (clr & 2) out2++;
// con esto he pasado he hecho lo siguiente, donde a y b representan un pixel con 4 posibles colores
// 00000000 000000ab -> 0000000b 0000000a
}
// vuelca los valores al fichero
putc(out1, fpo);
putc(out2, fpo);
}
}
Voy a hecharle un ojo a lo que has comentado, gracias por el esfuerzo!
Los primeros son octillizos, los siguientes tienen pinta de ser gemelos de distintos padres, y hay uno que a mi me da que es un primo. Lo que esta claro es que son todos de origen persa con rasgos latinos.
Santo cielo, ¡qué pregunta!
Ni caso te hago.
Otra opción es que hagas los gráficos en gimp (asegúrate que está en modo indexado y máximo 4 colores) y lo guardas como .h ó .c. Ahora haces un pequeño programita que transforme de los arrays de salida de Gimp al tipo que quiere la NGC. Este programita los gurús de C de aquí lo harán en medio minuto. Por ejemplo:
int main(int argc, char ** argv) {
int i;
int c=0;
for(i=0; i<64; i++) c += (i * 4 + header_data[i]);
printf("0x%0x\n", c);
}
Y esto lo tienes que hacer para cada tile. Como ejemplo, con este programita este dibujo en Gimp
29947
Dice que se codifica como 0x2011
(ahora toca saber exactamente qué bits son columnas y filas y colores, pero eso es solo retocar los números)
-----Actualizado-----
(Buf, me he liado mucho y no estoy nada seguro de lo que he dicho...)
Voy a mirar si con el gimp como comentas puedo hacer algo posterio para transformarlo.
La verdad es que todo ésto se me complica un poco, principalmente porque nunca he trabajado con bytes directamente o con transformación y utilización de bitmaps anivel de código y se me escapa un pelín todo ésto. Lo que estoy haciendo es volver loca a la gente y al mismo tiempo a mí, porque no se ni por donde empezar :D
Gracias a todos pos vuestras respuestas aclaratorias y positivas.
Si no lo ves claro coge un papel cuadriculado y dibujas ahí el esquema de los bytes y palabras de 16bits y como se modifican con cada operacion. Es facil, en los libros de ensamblador (cualquiera) puedes mirar como va el manejo de operaciones con bits, cuando te acostumbres lo harás de cabeza.
Haohmaru
19/12/2012, 00:24
Seguro que si, empezaré por ahí entonces.
Gracias swapd0
Powered by vBulletin® Version 4.2.5 Copyright © 2026 vBulletin Solutions Inc. All rights reserved.