AFAIK no hay puertos existentes de esta fuente para ninguna variante de esquema. Sin embargo, aquí hay algunos detalles y trucos que pueden ayudarte en el camino.
El t.fnt , Tektite, fue creado por el software clySmic (¿anterior?) Y probablemente Ralph B Smith Jr, presidente / jefe de programadores / cocinero / lavador de botellas . Es una fuente de mapa de bits que se incluyó con el programa VFONT para DOS y OS / 2. Carga fuentes de reemplazo para sistemas VGA. Su nombre dado por el autor es Tektite y se describe como "una fuente de estilo" Arquitecto "".
VFONT se puede descargar en los archivos CVFONT.ZIP y CVFONTA.ZIP. La fuente Tektite es parte de esta última. La primera es una versión anterior solo para DOS.
VFONT y extracción:
El archivo consta del programa DOS, VFONT.COM, el programa OS / 2 VFONT2.EXE, una base de datos de fuentes VFONT.DAT y un archivo README.MAN. El VFONT.DAT contiene 13 fuentes de mapa de bits almacenadas de forma consecutiva. Para extraer la fuente Tektite haz:
dd if=VFONT.DAT of=t.fnt bs=1 skip=28672 count=4096
Esto le proporciona un archivo de fuente de tipo RAW, que es el que se incluye, por ejemplo, en Slackware.
Cada fuente tiene 4096 bytes. Por lo tanto, para extraer los demás, simplemente cambie la opción de omisión . Es decir, lo c.fntque viene después t.fntle da un valor de omisión de 28672 + 4096 = 32768. Todas las fuentes están incluidas en Linux, y para hacer una extracción completa se podría hacer:
#!/bin/bash
pos=0
for n in s sd r ro rl mu ml t c b m mr sc; do
dd if=VFONT.DAT of=$n.fnt bs=1 skip=$pos count=4096
((pos += 4096))
done
... o, por supuesto, descárguelo de una de las diversas distribuciones que los incluye.
Estos archivos se pueden cargar directamente en la terminal, por ejemplo:
setfont t.fnt
Nombrar en Linux
La fuente recibió su nombre en Linux por las opciones para el programa VFONT. Tektite tiene /T. Las otras fuentes también están incluidas, también son nombradas por la opción de línea de comando para VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... etc.)
Fuentes RAW
El formato de fuente RAW (obsoleto pero reconocido) es el formato de fuente más simple que existe. No tiene encabezado, pie de página, no tiene bytes de escape, etc. Generalmente tiene un ancho de 8 píxeles (bits), al igual que las fuentes VFONT. Siempre tienen 256 glifos.
A partir de esto, podemos calcular fácilmente la altura mediante:
file_size (bits) 8 × 4096
h = -------------------- e.g. h = ------------- = 16
w × 256 8 × 256
Como todas las fuentes VFONT tienen un tamaño de 4096, también sabemos que tienen una altura de 16 píxeles (bits). Eso también da que cada glifo es de 16 bytes.
Representación ASCII
Como las fuentes se ajustan al rango ASCII cuando se trata de 0x20 (espacio) - 0x7e (tilde) podemos hacer una representación ASCII simple de los glifos.
Por ejemplo, la letra Atiene la posición 65. Como cada glifo es 8 × 16 = 128 bits, los tenemos a 128/8 = 16 bytes.
Como 65 × 16 = 1040 podemos extraer el glifo Apor (aquí incluye la conversión a binario y el reemplazo de 0 y 1 para hacerlo más legible):
xxd -s 1040 -l 16 -b -c 1 t.fnt | cut -d' ' -f 2 | tr 0 ' ' | tr 1 '#'
Lo que nos da:
Output from | Data in file
command: | Binary: Hex: Offset Offset
| Hex: Dec:
| 00000000 00 410 1040
| 00000000 00 411 1041
## | 00011000 18 412 1042
## | 00011000 18 413 1043
#### | 00111100 3c 414 1044
# # | 00100100 24 415 1045
## ## | 01100110 66 416 1046
## ### | 01101110 6e 417 1047
#### # | 01111010 7a 418 1048
### ## | 11100011 e3 419 1049
## ## | 11000011 c3 41a 1050
## ## | 11000011 c3 41b 1051
| 00000000 00 41c 1052
| 00000000 00 41d 1053
| 00000000 00 41e 1054
| 00000000 00 41f 1055
Usando un código C simple, también podemos renderizar algunas imágenes PBM simples. Aquí hay una salida de muestra de todas las fuentes en VFONT:
Edición con FontForge
Si desea trabajar con la fuente, supongo que puede ir a FontForge . Como no reconoce las fuentes RAW, debe convertirlo a otro formato. Una de las conversiones más simples podría ser a BDF. Una opción es usar las herramientas PSF de John Elliot . Primero convierta de RAW a PSF, luego PSF a BDF:
raw2psf t.fnt t.psf
psf2bdf t.psf t.bdf
El archivo BDF ahora se puede abrir en FontForge
Como el proceso es bastante simple (y lo mismo para todos los VFONT), también puede usar este script para convertir directamente al formato BDF:
Uso de la muestra:
./raw2bdf Tektite t.fnt > t.bdf
Te da la fuente Tektite como BDF.
#!/bin/bash
if [ $# -lt 2 ]; then
printf "Usage: %s <NAME> <raw-fnt-file>\n" $0
exit
fi
name=$1
file=$2
cat <<EOM
STARTFONT 2.1
FONT $name
SIZE 16 75 75
FONTBOUNDINGBOX 8 16 0 -4
STARTPROPERTIES 3
FONT_DESCENT 4
FONT_ASCENT 12
DEFAULT_CHAR 255
ENDPROPERTIES
CHARS 256
EOM
hexdump -ve '/1 "%02x\n"' "$file" | awk '
BEGIN {
n = 0;
}
(!((NR - 1) % 16)) {
if (n > 0)
print "ENDCHAR"
printf "STARTCHAR C00%02x\n"\
"ENCODING %d\n"\
"SWIDTH 666 0\n"\
"DWIDTH 8 0\n"\
"BBX 8 16 0 -4\n"\
"BITMAP\n",
n, n
++n
}
{
print $0
}
END {
print "ENDCHAR"
print "ENDFONT"
}
'
Otras versiones
Hay varias versiones modificadas de la fuente Tektite. Si lo busca, opcionalmente agrega, por ejemplo, "clysmic" a la frase de búsqueda en la que puede estudiar.
Representación de imagen
Para completar, agrego el código C mezclado para crear la imagen de arriba. displayy convertson parte de ImageMagick .
Uso de la muestra:
$ ./fntsampler t.fnt hello a
## ### ###
## ## ##
## ## ##
## ### ##### ## ## #####
## ## ## ## ## ## ## ## ##
#### #### ### ## ## ## ##
### ####### ## ## ## ##
## #### ## ## ## ##
## #### ## ## ## ## ##
## ## ###### ## ## #####
$ ./fntsampler t.fnt "Hello World!" > hello.pbm
$ display hello.pbm
La imagen de muestra de todas las fuentes anteriores fue creada por:
$ for f in *.fnt; do ./fntsampler "$f" "$(printf "%-6s Hello ABC abc 123" "$f")" | convert - "${f%.*}.png"; done
$ convert -negate -append *.png collection.png
Código:
#include <stdio.h>
#include <errno.h>
#include <string.h>
int usage(char *me, char *s)
{
fprintf(stderr,
"Usage: %s <RAW-font-file> \"<string>\" [format] [[invert] | [dot] [blank]]\n\n"
" format p : PBM image (default).\n"
" a : ASCII.\n"
" invert i : invert b/w in PBM.\n"
" dot\n"
" blank : Dot / blank in ASCII mode.\n\n"
"%s\n"
,
me, errno ? "" : s
);
if (errno)
perror(s);
return 1;
}
int main(int argc, char *argv[])
{
char *me = argv[0];
char buf[4096];
size_t n;
char *p;
int i, j, k;
FILE *fh;
char *s;
char fmt = 'p', dot = '1', blank = '0';
if (argc < 3)
return usage(me, "Missing argument(s)");
if (!(fh = fopen(argv[1], "r")))
return usage(me, "Unable to open file");
if ((fread(buf, 1, 4096, fh) != 4096))
return usage(me, "Bad file size");
s = argv[2];
if ((n = strlen(s)) < 1)
return usage(me, "Empty string");
if (argc > 3)
fmt = argv[3][0];
if (fmt != 'a' && fmt != 'p')
return usage(me, "Unknown format");
if (fmt == 'a') {
dot = argc > 4 ? argv[4][0] : '#';
blank = argc > 5 ? argv[5][0] : ' ';
} else {
if (argc > 4 && argv[4][0] == 'i') {
dot = '0';
blank = '1';
}
printf("P1\n");
printf("#Text: \"%s\", using %s\n", s, argv[1]);
printf("%u 16\n", n * 8);
}
for (i = 0; i < 16; ++i) {
for (j = 0; j < (int)n; ++j) {
p = buf + (s[j] * 16) + i;
for (k = 7; k >= 0; --k) {
putchar((*p >> k) & 0x01 ? dot : blank);
}
/*putchar(' '); */
}
putchar('\n');
}
return 0;
}