Hola gente, ando leyendo el formato de mapa de imagen de bennuGD desde Java, y me surge una duda, siguiendo las indicaciones de AmakaSoft he podido obtener el ancho, alto, y el numero de puntos de control de un archivo .map de bennuGD "muchisimas gracias tio por la info ;) ".
Pero como info de cabecera o identificador de archivo estoy obteniendo los chars "m16", esto es correcto? que significan?
bueno.. es una duda algo tonta pero abro el hilo para ir comentando futuras dudas que me vayan surgiendo :)
(http://forum.bennugd.org/index.php?action=dlattach;topic=4151.0;attach=3333)
Bueno me autorespondo, haciendo mas pruebas parece que 'm16' indica que es un archivo .map a 16 bit de profundidad de color, y si obtengo 'm32' indica que está a 32 bits de profundidad de color.
Ale una cosa menos jeje..
Tienes los formatos del FPG y de los MAP implementados aquí:
http://sourceforge.net/p/bennugd/code/HEAD/tree/modules/mod_map/file_fpg.c
http://sourceforge.net/p/bennugd/code/HEAD/tree/modules/mod_map/file_map.c
muchas gracias joseba, voy a hecharles un vistazo ya!!
Esto va viento en popa a toda vela, la verdad es que está siendo un ejercicio muy chulo este.
(http://forum.bennugd.org/index.php?action=dlattach;topic=4151.0;attach=3335)
Asi mirando el código del formato map.. jeje.. ahora recuerdo por que odio tanto programar en c++ jajajjajajajajajajjajajajajajajajajaja
Gracias de nuevo Joseba!
Ya he conseguido leer el archivo .map al completo yuhheuuuu!!!!
Pero me sale el color con diarrea XD.. en que orden vienen los bytes de color? creo haber entendido que estan en R G B A pero no se si estoy en lo cierto la verdad, estoy haciendo combinaciones haber si acierto pero vaya tela XD..
Quote from: Erkosone on December 31, 2015, 11:09:48 AM
Ya he conseguido leer el archivo .map al completo yuhheuuuu!!!!
Pero me sale el color con diarrea XD.. en que orden vienen los bytes de color? creo haber entendido que estan en R G B A pero no se si estoy en lo cierto la verdad, estoy haciendo combinaciones haber si acierto pero vaya tela XD..
xD Lo del color me paso también a mi, el orden es ARGB, primero el alpha. xD
Un saludo.
Otra cosa es si el alpha lo interpreta igual java que bennu, en javascript el alpha es decimal y va de 0 a 1, por lo que el valor alpha lo tuve que dividir en 255.
Gracias tio! creo que por ahí van los tiros jeje.. me suena de cuando hice el blitter que el alpha es de cero a 1 jejeje.. creo que ya lo tengo!
Estoy en ello XD.. maldito color jejejeje...
(http://forum.bennugd.org/index.php?action=dlattach;topic=4151.0;attach=3337)
Solucionado! en java(processing) inyecto los bytes como (b,g,r,a) y listo.. por ahora me conformo asi jejeje....
Gracias!!!!
Me pasa algo que no se arreglar, cuando el tamaño de la imagen supera en alto o ancho los 254 pixels me lee mal el ancho y alto, creo que tiene que ver con los byte´s de donde estoy leyendo el ancho y alto, pego el código que es bastante poco y sencillo de seguir, si no he entendido mal, los bytes 8 y 9 son el ancho y los 10 y 11 son el alto.
Lo hago así pero con imagenes de mas de ancho que lo que cabe en un byte hace puff.. haber si doy con el error..
EDIT: si en las variables ancho y alto coloco yo a mano los valores correctos todo funciona perfect.. que cosa mas curiosa.
PImage mapa;
int ST = 0;
//----------------------------------------------------------------------
void Setup() {
setMode(1280, 900 );
setVirtualResolution(640, 400);
setFps(60);
worldSetGravity(-90, 100);
}
//----------------------------------------------------------------------
void Main() {
switch(ST) {
case 0:
mapa = loadMap("001.map");
ST = 10;
break;
//----------------------------
case 10:
blitter.image(mapa, 150, 150);
break;
}
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
PImage loadMap(String fileName) {
// datos del archivo de imagen..
String header = ""; // cabecera del archivo..
String mapDesc = ""; // descripcion del mapa..
int ancho; // ancho del archivo..
int alto; // alto del archivo..
int numCPoints; // numero de puntos de control que contiene el archivo..
byte[] map = loadBytes(fileName); // bytes en raw del contenido del archivo..
int offset; // posicion donde empieza la información RGBA de la imagen..
int counter = 0; // usando en el dump de RAW BYTES al array de pixels..
for(int i=0; i<7; i++){
header += char(map[i]);
}
for(int i=13; i<45; i++){
mapDesc += char(map[i]);
}
// paso de signed a unsigned bytes..
ancho = (map[8] & 0xff) + (map[9] & 0xff);
alto = (map[10] & 0xff) + (map[11] & 0xff);
numCPoints = (map[48] & 0xff);
println("header: " + header);
println("Description: " + mapDesc);
println("ancho : " + ancho);
println("alto : " + alto);
println("CP´s : " + numCPoints);
// crear el array de puntos de control..
cPoint[] cp = new cPoint[numCPoints];
// rellenar el array con las coordenadas de los puntos de control..
for(int i=0; i<numCPoints; i++){
cp[i] = new cPoint();
cp[i].x = (map[49+i*4] & 0xff) + (map[50+i*4] & 0xff);
cp[i].y = (map[51+i*4] & 0xff) + (map[52+i*4] & 0xff);
println("CP[" + i + "] : " + cp[i].x + " " + cp[i].y);
}
offset = (52 + numCPoints * 4) +1;
// RGBA pixel´s load..
PImage img = createImage(ancho, alto, ARGB);
int r,g,b,a;
colorMode(RGB, 255);
for (int i=0; i+offset+4< map.length; i+=4) {
a = (map[offset + i+0] & 0xff);
r = (map[offset + i+1] & 0xff);
g = (map[offset + i+2] & 0xff);
b = (map[offset + i+3] & 0xff);
img.pixels[counter] = color( b,g,r, a);
counter ++;
}
img.updatePixels();
return img;
}
//----------------------------------------------------------------------
class cPoint{
int x = 0;
int y = 0;
}
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
//----------------------------------------------------------------------
Si, los bytes 8 y 9 son el ancho y los 10 y 11 el alto, pero no se deben sumar tal cual.
A ver si así te funciona:
ancho = (map[8] & 0xff);
alto = (map[10] & 0xff);
if ((map[9] & 0xff) > 0) ancho += 256 * (map[9] & 0xff);
if ((map[11] & 0xff) > 0) alto += 256 * (map[11] & 0xff);
Un saludo.
P.d: Y esto es lo mismo para la posición x e y de los cpoints.
Dios si, acabo de despertar de la siesta y mi cerebro me ha dado una bofetada XD.. tienes toda la razón del mundo, se me ha ido la olla completamente jeje...
Gracias tio, ya te digo, me he despertado de dormir con el tipico "coño!, soy retrasado!". :)
Vaya tela, gracias tio.. esto es un claro inicio de demencia senil jaja..
me he montado esto ya para el api que estoy construyendo:
int getWord(byte[] arr, int off) {
//return arr[off]<<8 &0xFF00 | arr[off+1]&0xFF;
if ((arr[off] & 0xff) > 0){
return (arr[off] & 0xff) + (256 * (arr[off+1] & 0xff));
}
else{
return (arr[off+1] & 0xff);
}
}
Pues ya tengo los .map funcionando a tope!!!!! que pasote, el formato de bennuGD rulando el java con suavizado y shaders jejejejejejeje...
empiezo a babear muahahhaah...
Gracias por toda la informacion, ya para mañana los .FPG! ;)
(http://forum.bennugd.org/index.php?action=dlattach;topic=4151.0;attach=3339)
Bueno pues ya lo tengo, que bien!! Gracias por la ayuda gente!! ;D
Ya puedo leer archivos de bennuGD desde "processing", tanto archivos .map como archivos .fpg.
Si alguien necesita el modulo para cargarlos en este lenguaje le paso el código sin problema ;)
(http://forum.bennugd.org/index.php?action=dlattach;topic=4151.0;attach=3341)
y los cargas todos sin errores, digo todos los formatos ? mira que soy lamer llevo mas de 1 año y todavia no he terminarlo de hacerlo al 100% ;(
Bueno en mi caso particular solo voy a usar el formato de 32 bits ya que en processing que es para donde lo he preparado solo está disponible en 32 bits para win/linux/mac/android/web por opengl..
Los formatos de 16 bits realmente no me los he ni planteado pero quizá sería de utilidad leerlos aunque sea solo para cargarlos como imagenes en memoria realmente de 32bits.
Bueno, siendo sincero, en processing se puede trabajar con imagenes en formato RGB sin alpha que serían los 16 bits pero realmente no me he puesto a mirar el formato 16 bits ni 8.
La verdad es que no jeje, solo lo he hecho para 32 bits :P
Pues los formatos de 16 y 8 bits son casi más de lo mismo.
Los de 16bits tienen cabecera M16, y luego los pixels vienen en formato RGB usando 5, 6 y 5 bits respectivamente (ojo, BITS, no BYTES, porque son 16 BITS cada pixel). El color transparente es el color 0, o sea, el negro absoluto.
Los de 8 tienen cabecera MAP (por compatibilidad con los viejos de DIV), y añaden un pequeño espacio para la paleta de colores y para las gammas (son información extra para poder usar la herramienta de degradados en DIV, pero en la práctica no se usan).
Los FPG tres cuartos de lo mismo. Por mi disco duro debo tener los códigos para leerlos y generarlos desde Fenix y BennuGD, byte a byte.
Lo que aun no he conseguido son los formatos de 1bit y los FNT (sobre todo porque intenté sustituir los caracteres por "tiles" :D).