Hola SplinterGu,
una preguntilla, he visto que hay dos posibilidades para guardar un fnt en 8 bits, guardando el magic con 'fnt' y usando el "oldchardata"
Y guardando el magic con "fnx", la versión con 8 bits y usando el "newchardata".
Mi pregunta es. ¿Ambos fnts de 8 bis funcionan en BennuGD?
Es que la primera prueba que he hecho es convertir un "fnt" a un fnx de ocho bits y he creado un ".prg" para probarlo y me devuelve el load_fnt siempre "-1".
Gracias de antemano.
en teoria, deberian...
creo que uno es formato div y otro formato fenix
Nada, llevo dos dias perdidos dando vueltas a esto, no se me ocurre el motivo de que no funcione en bennu la fuente fnx de 8 bits.
Me he hecho un visor para poder ver exactamente qué datos hay en el fnt y en el fnx para ver si es que está mal el offset o algo y nada, parece estar todo correcto pero bennu siempre me devuelve -1
Te adjunto pruebas para ver si puedes ayudarme a encontrar la falla.
splinter, he modificado el fntviewer para que muestre también la información de paleta y gamma por si podría estar por ahí el error, pero nada, está todo correcto, en teoría.
Creo que tiene que ser un error de bennu en la lectura de fnx de 8 bits, es la única explicación que encuentro por ahora.
no se como lo estas haciendo, pero el fnx funciona bien... prueba grabar el fnt cargado como fnx y luego cargalo en el test de fnx, y veras como funciona...
voy a describir el formato fnx:
1) cabecera 8 bytes ("fnx\x1A\x0D\x0A\x00" + 1 byte de profundidad de color)
2) si 8bpp -> 768 de paleta + 576 bytes de gamma (se ignora el contenido de la gamma)
3) 1 dword (4 bytes) charset
4) struct chardata[256] (28 * 256 = 7168 bytes)
5) 256 caracteres (nunca mas o menos) que se compone de la data del char o mapa, que es "ancho en bytes" * alto (donde "ancho en bytes es", en 1bpp = 1byte cada 8pixels, 8bpp = 1, en 16bpp = 2, en 32bpp = 4)
eso es el formato, y asi funciona correctamente.
edite, el texto porque me confundi, pero funciona igual...
de paso al revisar esto, me di cuenta que estoy usando directamente las funciones de gzip, voy a cambiar eso.
saludos.
q tal fue esto? por favor, manteneme al tanto.
Oh, sorry.
A ver, te pongo al día y de camino te pregunto otra cosilla.
En principio el problema era que en el chardata yo estaba tratando solo 6 campos, me salté sin querer el campo horizontal_offset (:D), solventado ese problema, he probado a generar fuentes de 1,8,16,24 y 32 bits y a ver.
las de 1 bit no me van, el offset no lo calculo bien, este formato es bastante peculiar y dificil de programar por lo de no ser secuencial :(. Tengo que recontruir el motor de generación de offset que tengo actualmente.
Las de 8 bits van perfectas,
Las de 16 bits los colores fallan, no se porqué motivo, a ver si me puedes aclarar en qué formato se guardan los dos bytes de cada pixel, actualmente he probado con GBR en 565 y no me fué, me salen los colores cambiados, también he probado en RGB 565 y nada.
Las de 24 bits no puedo progarlas porque no funcionan en bennu, el formato es RGB en 888(copiado de las de 32 bits pero sin el canal alfa)
Las de 32 bist van muy bien excepto por un fallo en el alfa, no cambia y siempre usa 255, esto viendo el motivo, parece ser que no reconoce el color a cambiar el alfa.
bien, ya me parecia raro que en esto tenga errores esa parte de bennu...
en 16 bit... siempre es RGB 565... pero hay unas funciones de conversion raras, que se usan solo en los fonts y en los fpg... pero mas alla de eso, creo que las conversiones estan siendo nulas, ya que convierten de screen a 565, pero screen es 565, asi que no hace nada...
por que no pones la parte del codigo que se encarga de hace esto y lo vemos, como tambien fonts de ejemplos?
el formato 1bit es simple... 1 byte puede contener desde 1 hasta 8 pixels, 1,2,3,4,5,6,7 u 8 de ancho es 1 byte... si tenemos menos de 8 pixels el resto del byte no usado se descarta y no se usa para nada.
32 bits, es lo que dice la informacion del font, no se hace ningun tipo de conversion, asi que estas vos forzando a 255, o en la carga del mapa o char o en la grabacion del font.
Pues, vamos a ver como lo hago, el código es delphi (pascal)
Ya medio va todo pero regulin regulan.
Los fnts de un bit salen cortados por el final, no entiendo el porqué.
los fnts de 16 bis los colores son cambiados, te adjunto estas dos fuentes y un visor que he hecho para leerlas
adjunto visor. Si abres con el visor las fuentes de 8 y 32 bits verás los colores originales, si abres la fuente de un bit verás el error de cortado, si abres la de 16 verás el color invertido RGB en vez de GBR. (esto tengo que cambiarlo, ahora mismo es así porque es la forma nativa de 16 bits de delphi) El problema es que al abrir el ejemplo de bennu, los colores de esta fuente son distintos a los de en 8 y 32 bits.
He revisado sendas veces el 16 bits y el 1 bit y no encuentro el fallo.
el código implicado es el siguiente:
Para el caso de un bit, la imagen está guardada en pixel format de 8 bits por pixel, asi que recorro esta imagen byte a byte y si el byte (= pixel) es distinto de 0 inserto un 1 en la variable que uso para construir los bytes del pixel format 1 bit. Cuando tengo ya 8 pixeles leídos o no tengo más que leer en la línea grabo.
for k := 0 to mybitmap.Height - 1 do <--- recorre todas las filas
begin
pSrc := mybitmap.ScanLine[k]; <-- obtiene los datos de los píxeles de una fila entera
case fnt_info.version of
1:
begin
insertedBits :=0;
byteForFPG1 :=0;
for h := 0 to fnt_info.chardata[i].Width -1 do begin
if pSrc[h] <> 0 then begin
byteForFPG1 := byteForFPG1 OR 1; // bit más alto en 8 bits
end;
insertedBits := insertedBits +1;
if (insertedBits = 8) or (h = 0) then begin
while insertedBits <>8 do begin
byteForFPG1 := byteForFPG1 shl 1;
insertedBits := insertedBits +1;
end;
f.Write(byteForFPG1, 1);
byteForFPG1 :=0;
insertedBits :=0;
end else
byteForFPG1 := byteForFPG1 shl 1;
end;
end;
8:
begin
f.Write(pSrc^, fnt_info.chardata[i].Width);
end;
Para 16 bits ,la imagen internamente está en 16 bits windows/delphi, así que hay que convertirla en 16 bits bennu
16:
begin
for m := 0 to fnt_info.chardata[i].width - 1 do begin
RGBtoBGR(byte_line[0], byte_line[1],
pSrc[(m*2)], pSrc[(m*2) + 1]);
f.Write(byte_line, 2);
end
end;
la función rgbtobgr es por lo que comenté del sistema nativo de 16 bits de windows/delphi.
hace esto:
procedure RGBtoBGR( var bgr0,bgr1: Byte ; rgb0, rgb1 : Byte);
begin
R16 := rgb1 shr 3;
G16 := ((rgb1 and $7) shl 3) + (rgb0 shr 5); //#00000111
B16 := rgb0 and $1F; //#00011111
num := (B16 shl 11) + (G16 shl 5) + R16;
bgr0 := num AND $FF;
bgr1 := (num shr 8 )AND $FF;
end;
en el codigo de 1 bit... al final de esto
end else
byteForFPG1 := byteForFPG1 shl 1;
end;
tenes que chequear, si insertedBits > 0, entonces tenes que insertar ese byte... con los bits seteados hasta insertedBits y el resto a 0.
la rotacion deberias hacerla al inicio de cada ciclo del for... y no al final...
mejor deberia quedar asi...
byteForFPG1 :=0;
for h := 0 to fnt_info.chardata[i].Width -1 do begin
if pSrc[h] <> 0 then begin
byteForFPG1 := byteForFPG1 OR (1 shl (h and 7));
end;
if (h and 7) = 7 then begin
f.Write(byteForFPG1, 1);
byteForFPG1 :=0;
end
end;
if (h and 7) <> 7 then begin
f.Write(byteForFPG1, 1);
end
con respecto a 16 bit, no es BGR, es RGB. Windows no usa un sistema diferente de bennu, asi que si delphi usa el mismo que windows, entonces es el mismo que bennu.
ahora estoy un poco complicado para analizar el tema de los 16bits... cuando tenga un tiempo si no lo resolviste lo reviso mas detenidamente...
saludos.
gracias, voy a ver que tal, a las dos cosas, aunque si no recuerdo mal ya probé lo de los 16 bits RGB sin buen resultado. Por cierto, eso que comentas de que en 16 bits es RGB es solo para FNTS entonces ¿no?. Porque en el editor FPG 2009 está GBR para fenix con magic "f16" y RGB para cdiv con magic "c16".
Mala suerte, no fué ninguna de las dos cosas.
He intentado hacer un pantallazo mostrando los puntos importantes del test.
El de 32 bits, actualmente es un "arreglo de compromiso", lo que hago es insertar la componente alfa a última hora para ello miro el color del pixel y si es sombra inserto el alfa de sombra y si es reborde inserto el alfa de reborde. Lo hize así para tener una primera versión rápida sin tener que tocar mucho el núcleo del fntedit.
El de 1 bit, inserté tu código tal cual, lo hiciste un poco ofuscado, o no tengo tanto nivel para entenderlo :(. Mi algoritmo anterior lo seguí con lapiz y papel y funcionaba perfectamente, yo insertaba el último trozo incompleto cuando llegaba a "h = 0", vale creo que vi el fallo, tengo que cambiarlo por width -1 e irá, :D mientras te lo explicaba ví la luz, voy a probarlo.
El de 16 bits he hecho un mapeo directo de los dos bytes que usa windows y se ve eso que muestro en la pantalla, unos colores inventados totalmente :D.
El de 24 bits me va perfecto, también es mapeo directo de los tres bytes que usa windows, y si lo abro con mi fntviewer se ven todos los caracteres, lástima que no vaya en bennu :(. A mi gusto le faltan dos cosillas en el manejo de imágenes a bennu, una es esta y otra es poder cambiar la paleta de un map por otra, esta técnica es muy buena para hacer por ejemplo dobles de malos con otros colores sin tener que repetir y colorear en un programa externo todos los sprites base.
El de 8 bits FNX también va de lujo, vamos esto era de esperar, si lo hacía antes con el 8bits FNT, solo fue añadir campos nuevos y reajustar los file_offset :D.
Post Data: Si quereis generar fuentes con 32 bits para ya, podría subir una versión castrada solo para este formato.
JUASJUAS, he visto que pasa tokiski de los ejemplos que pongo, "0 descargas" y uno que tiene 1 descarga es porque me lo bajé yo :D.
Gracias a todos los que os lo bajasteis :D.
No os ofendais, es bromita.
Gracias Splinter, ya ho nace falta que revises lo de 1 bit, era esa tontada, sabía que tenía que ser algo estúpido pero no creí que tanto :D, valla fallacaco que tuve. En mis ejercicios de papel siempre usaba como límite el último valor en cambio en lo programado usaba el primer valor, así que salía todo como cortado :D. lo corregí cambiando el if que inserta en el archivo por este otro
if (insertedBits = 8) or (h = fnt_info.chardata[i].Width -1 ) then begin
Lo de los 16 bits ya está fuera de mi alcanze si no va el mapeo directo ni el cambio a GBR me parece queesta vez tendrá que ser de bennu, además pasa unas cosas curiosísimas:
Si cambio a 16 bits el prg de bennu, al cargar la fuente de 16 bits el programa se cuelga, tengo que eliminarlo con el administrador de tareas.
Si elimino la carga de la fuente de 16 bits, el programa funciona, muestra la de 1 bit, la de 8 bits y no muestra la de 32 bits, pero no se cuelga.
Si elimino la carga de la de 32 bits y la de 16 bits va bien.
Edit: he visto que el cambio de color también se produce en delphi al cambiar de 8 a 16 bits, parece que no hace los shifts y trunca, voy a ver si lo corrijo.
estas loco, yo he bajado tus ejemplos... y aca veo bien la cantidad de descargas.
vamos que el ejemplo que puse es superbasico, nada ofuscado, es simple, lo unico que hago es rotar el valor que vas a utilizar en el OR, con lo que te ahorras un monton de loops. como no se delphi, puede que el codigo necesite algun ajuste, pero deberia funcionar a la perfeccion.
proba generar fonts en bennu y cargarlos tambien en bennu... luego pruebas en tu aplicacion en base a esto...
para ver 32 bits necesitas un modo de video 32... nunca se pueden visualizar graficos de mayor profundidad que el modo de video.
Lo siento si te molestó, no lo dije por tí, a las pruebas me remito.
En lo referente a las descargas he probado firefox, explorer y opera desde dos equipos distintos y me sigue saliendo 0 descargas en dos de los adjuntos. Mira la imagen que adjunto.
En lo referente a los 1 bits, no quise insinuar que lo hicieras a propósito, el código que propusiste lo probé tal cual y no iba lo intenté entender para solventarlo y no pude, date cuenta que cambiaste bastante la lógica de mi algoritmo, por ejemplo eso de OR (1 shl (h and 7) cuesta entenderlo un poquito. Y el porqué del desplazar al principio, si haces eso entonces nunca tendrás un 1 en el bit menos significativo al guardar el byte ya que se le hizo al principio el desplazamiento.
De todas formas gracias a tu código ví el fallo en el mío, te dí las gracias eh,
En cuanto a los 16 bits, a través de pruebas en delphi, he visto que windows trata los 16 bits (un word por pixel) como B5G6R5, al igual que fenix. Lo que pasa es que los demás formatos de píxeles los trata RGB, así que al transformar de cualquier formato de pixel a formato de 16 bits se le va la pinza al delphi y cambia los colores. He solventado el problema pasando a 24 bits primero y desde éste generar los word B5G6R5 necesarios para 16 bits.
Ahora creo que sí que he detectado algún problema en bennu con los 16 bits. El mismo código que adjunto en fenix va bien incluso carga el fnt de 16bits y en bennu no va, se cuelga, hace como bucle infinito y hay que eliminar con el administrador de tareas.
En cambio cuando pruebo el mismo en bennu pero con deph 32, entonces se ve mal la fuente de 16 bits.
También he intentado cargar un fnt 8btis en bennu desde modo 16 bits y guardarlo en fnt16 bits y no funciona, sigue guardandolo en 8 bits.
Espero no te enojes mucho conmigo por la guerra que te doy :(, he estado a saco estos días a atrás para poder entregaros una versión revisada con 32bits del fntedit a la comunidad, a veces me desespero porque no sale como yo quiero y además siempre viene muy bien tu ayuda, la ayuda del que conoce a fondo el sistema.
Yo baje tus ejemplos, sino como fue que te puse el codigo para que pruebes y te dije en base a los fonts que me pasaste de ejemplo?
con respecto a los 2 ultimos attachs, no los vi, disculpa, estoy con 3 proyectos a la vez, y al ver el codigo, no me preocupe en ver si habia attach. Disculpa, pero los anteriores si los baje.
el desplazamiento es solo del valor 1, ves que hay parentesis?
esto es
1 << 0 = 1
1 << 1 = 2
1 << 2 = 4
1 << 3 = 8
1 << 4 = 16
1 << 5 = 32
1 << 6 = 64
1 << 7 = 128
ahi tenes todos los OR para cada uno de los pixels... es muy simple...
el AND 7 ( 0111b ) hara que solo se considere el modulo 8 de la posicion de cada columna.
Los cuelgues no se, tendre que probarlo.
Claro, un font siempre mantiene su profundidad de colores, seria un error que asi no sea. Si queres convertir un font de 8 a 16, tenes que crear un nuevo font e ir copiando mapa a mapa, haciendo la conversion... mira el ejemplo de pacman que inclui en la distro de wiz... ahi tenes un ejemplo de como crear un font a partir de otro.
Je, se que le estas dando duro, no te preocupes... es que yo tambien estoy con varias cosas a la vez, el tiempo no me alcanza y me desespera tener solo 2 dias los fines de semana... y que gran parte del dia le tenga que dedicar a salir de compras o salir a donde sea... en estos momentos odio salir...
A todo esto me pregunto, el editor de fonts de prg, no generaba fonts en todos los modos bien? o lo soñe?
probe tu ejemplo con los 4 fonts, que setea el modo de video a 32 bits... y yo veo los 4 fonts...
proba este codigo
import "mod_map";
import "mod_draw";
import "mod_say";
#define CONVERT 0
function font_convert( int source, int depth )
private
font, i, w, w1, h, d, gr, gr2, p1, p2;
begin
font = fnt_new(depth);
/* Resize fonts */
for (i = 0; i < 128; i++)
gr = glyph_get( source, i );
if ( gr )
w = map_info(0,gr,g_width);
h = map_info(0,gr,g_height);
d = map_info(0,gr,g_depth);
gr2 = map_new(w, h, depth);
point_set(0,gr2,0,0,0);
map_xput(0, gr2, gr, 0, 0, 0, 100, B_NOCOLORKEY);
point_get(0,gr,0,&p1,&p2);
point_set(0,gr2,0,p1,p2);
point_get(0,gr,1,&p1,&p2);
point_set(0,gr2,1,p1,p2);
point_get(0,gr,2,&p1,&p2);
point_set(0,gr2,2,p1,p2);
if ( depth == 32 )
w1 = w;
while ( h-- )
w = w1;
while ( w-- )
map_put_pixel(0,gr2,w,h,map_get_pixel(0,gr2,w,h)&07fffffffh);
end
end
end
glyph_set( font, i, 0, gr2 );
map_del(0,gr2);
map_del(0,gr);
end
end
return font;
end
Global
depth = 32;
teoricFPS=30;
id_fnt1 =0;
id_fnt8 =0;
id_fnt16 =0;
id_fnt32 =0;
Begin
set_title("fuente 32 bits FNX");
#if CONVERT
set_mode(640,480,16);
#else
set_mode(640,480,depth);
#endif
set_fps(teoricFPS,0);
put_screen(0,load_png("fondo.png"));
id_fnt1=load_fnt("fuente1bpp.fnt");
#if CONVERT
id_fnt8=load_fnt("fuente8bppFNX.fnt");
id_fnt16=font_convert(id_fnt8,16);
id_fnt32=font_convert(id_fnt16,32);
#else
id_fnt8=load_fnt("font8-bennu.fnt");
id_fnt16=load_fnt("font16-bennu.fnt");
id_fnt32=load_fnt("font32-bennu.fnt");
#endif
write(id_fnt32,100,200,0,"hola32");
write(id_fnt16,100,150,0,"hola16");
write(id_fnt8,100,100,0,"hola8");
write(id_fnt1,100,50,0,"hola1");
while (!key(_esc))
if (key(_f))
if (full_screen==true)
full_screen=false;
else
full_screen=true;
end
set_mode(800,600,depth);
while (key(_f))
frame;
end;
end
frame;
end
#if CONVERT
save_fnt(id_fnt8, "font8-bennu.fnt");
save_fnt(id_fnt16, "font16-bennu.fnt");
save_fnt(id_fnt32, "font32-bennu.fnt");
#endif
end
No uses la funcion de save para mapas de 16 bits... no funciona en esta version... tengo que sacar la tabla de conversion... y convertir mas de 128 mapas tambien da problemas, tengo que analiar que pasa...
la grabacion de 16 bits ya funciona bien en una version que tengo eliminando esas siniestras funciones de conversion que mencione...
como sea, aca te paso un set de fonts correctos... segun tu font de 8 bits...
el font de 1 bit que incluiste en el ejemplo, sigue estando mal, ya que tiene una banda negra del lado izquierdo, supongo que producto de las rotaciones... o quizas este font es viejo.
tambien podras ver que el alpha en 32bits funciona perfecto.
Saludos.
mira, con tu mismo ejemplo he visto el error, te recuerdo que yo uso windows, primeramente la fuente de 16 bits muestra los colores erróneos, en teoría es igual a la de 8 bits. Si pruebas a cambiar la resolución a 16 y eliminas las loadfont de 1 y 32 bits el programa entre bucle infinito, Esto mismo probado en fenix va bien y además se ven los colores de la fuente de 16 bits correctamente.
#define CONVERT 0
Global
depth = 16;
teoricFPS=30;
id_fnt1 =0;
id_fnt8 =0;
id_fnt16 =0;
id_fnt32 =0;
Begin
set_title("fuente 32 bits FNX");
#if CONVERT
set_mode(640,480,16);
#else
set_mode(640,480,depth);
#endif
set_fps(teoricFPS,0);
put_screen(0,load_png("fondo.png"));
//id_fnt1=load_fnt("fuente1bpp.fnt");
#if CONVERT
id_fnt8=load_fnt("fuente8bppFNX.fnt");
id_fnt16=font_convert(id_fnt8,16);
id_fnt32=font_convert(id_fnt16,32);
#else
id_fnt8=load_fnt("font8-bennu.fnt");
id_fnt16=load_fnt("font16-bennu.fnt");
//id_fnt32=load_fnt("font32-bennu.fnt");
#endif
write(id_fnt32,100,200,0,"hola32");
write(id_fnt16,100,150,0,"hola16");
write(id_fnt8,100,100,0,"hola8");
write(id_fnt1,100,50,0,"hola1");
while (!key(_esc))
if (key(_f))
if (full_screen==true)
full_screen=false;
else
full_screen=true;
end
set_mode(800,600,depth);
while (key(_f))
frame;
end;
end
frame;
end
#if CONVERT
save_fnt(id_fnt8, "font8-bennu.fnt");
save_fnt(id_fnt16, "font16-bennu.fnt");
save_fnt(id_fnt32, "font32-bennu.fnt");
#endif
end
pruebalo en fenix 92 preview 3 y en bennu rc95 desde windows.
puf... ya te lo he dicho y explciado cuando postee el mensaje...
usa para tu editor los fonts que subi, esos fonts van bien. la version que tienes de bennu, no muestra bien los colores, pero los fonts que te subi son los correctos.
Ah vale ahora entiendo, sorry, gracias por tu paciencia, ok, pues espero entonces, ya que actualmente el fntedit que tengo creo que genera bien los 4 formatos fnx, puesto que cuando los abro con el visor que hize tambien se ven bien.
efectivamente, probé todas tus fonts en el visor que hice y se ven correctamente. También he visto que los generados por el fntedit que tengo son análogos a los tuyos. Gracias, karma up.
Con la r99, el ejemplo funciona correctamente.
Buen trabajo Splinter.