AFAIK non ci sono porte esistenti di questo font per nessuna variante di contorno. Ecco comunque alcuni dettagli e alcuni hack che potrebbero esserti di aiuto lungo la strada.
Il t.fnt , Tektite, è stato creato dal (ex?) Software clySmic , e probabilmente Ralph B Smith Jr, presidente / capo programmatore / cuoco / lavabottiglie . È un carattere bitmap che è stato incluso con il programma VFONT per DOS e OS / 2. Carica font sostitutivi per sistemi VGA. Il nome dato dall'autore è Tektite e descritto come "un carattere in stile" Architetto "."
VFONT può essere scaricato negli archivi CVFONT.ZIP e CVFONTA.ZIP. Il carattere Tektite fa parte di quest'ultimo. La prima è una versione precedente solo per DOS.
VFONT ed estrazione:
L'archivio comprende il programma DOS, VFONT.COM, il programma VFONT2.EXE per OS / 2, un database di caratteri VFONT.DAT e un file README.MAN. VFONT.DAT contiene 13 caratteri bitmap archiviati schiena contro schiena. Per estrarre il carattere Tektite fai:
dd if=VFONT.DAT of=t.fnt bs=1 skip=28672 count=4096
Questo ti dà un file di font di tipo RAW, che è quello incluso in es. Slackware.
Ogni carattere è di 4096 byte. Quindi per estrarre gli altri basta cambiare l' opzione salta . Cioè c.fntche viene dopo t.fntti dà un valore di salto di 28672 + 4096 = 32768. Tutti i caratteri sono inclusi in Linux e per eseguire un'estrazione completa è possibile:
#!/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, naturalmente, scaricalo da una delle varie distro che li include.
Questi file possono essere caricati direttamente nel terminale ad esempio:
setfont t.fnt
Denominazione in Linux
Il font ha ricevuto il suo nome in Linux dalle opzioni per il programma VFONT. Tektite ha /T. Sono inclusi anche gli altri caratteri, anch'essi nominati dall'opzione della riga di comando per VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... ecc.)
Font RAW
Il formato di carattere RAW (obsoleto ma riconosciuto) è il formato di carattere più semplice che ci sia. Non ha intestazione, piè di pagina, nessun byte di escape ecc. Di solito ha una larghezza di 8 pixel (bit), così come i caratteri VFONT. Hanno sempre 256 glifi.
Da questo possiamo facilmente calcolare l'altezza:
file_size (bits) 8 × 4096
h = -------------------- e.g. h = ------------- = 16
w × 256 8 × 256
Poiché tutti i caratteri VFONT hanno una dimensione di 4096, sappiamo anche che sono tutti alti 16 pixel (bit). Questo dà anche che ogni glifo è di 16 byte.
Rendering ASCII
Poiché i caratteri sono conformi all'intervallo ASCII quando si tratta di 0x20 (spazio) - 0x7e (tilde), possiamo fare un semplice rendering ASCII dei glifi.
Ad esempio la lettera Aha posizione 65. Poiché ogni glifo è 8 × 16 = 128 bit, li abbiamo a 128/8 = 16 byte.
Come 65 × 16 = 1040 possiamo estrarre il glifo Ada (qui includendo la conversione in binario e la sostituzione di 0 e 1 per renderlo più leggibile):
xxd -s 1040 -l 16 -b -c 1 t.fnt | cut -d' ' -f 2 | tr 0 ' ' | tr 1 '#'
Che ci dà:
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 semplice codice C possiamo anche rendere alcune semplici immagini PBM. Ecco un esempio di output da tutti i caratteri in VFONT:
Modifica con FontForge
Se desideri lavorare con il carattere, suppongo che potresti andare a FontForge . Poiché non riconosce i caratteri RAW, è necessario convertirlo in un altro formato. Una delle conversioni più semplici potrebbe essere quella di BDF. Un'opzione è utilizzare gli strumenti PSF di John Elliot . Prima converti da RAW a PSF, quindi da PSF a BDF:
raw2psf t.fnt t.psf
psf2bdf t.psf t.bdf
Il file BDF ora può essere aperto in FontForge
Poiché il processo è piuttosto semplice (e lo stesso per tutti i VFONT), puoi anche utilizzare questo script per convertire direttamente in formato BDF:
Esempio di utilizzo:
./raw2bdf Tektite t.fnt > t.bdf
Ti dà il carattere Tektite come 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"
}
'
Altre versioni
Esistono diverse versioni modificate del carattere Tektite. Se lo cerchi, aggiungi facoltativamente, ad esempio, "clysmic" alla frase di ricerca su cui puoi studiare.
Rendering delle immagini
Per completezza, aggiungo il codice C creato per creare l'immagine sopra. displaye convertfanno parte di ImageMagick .
Esempio di utilizzo:
$ ./fntsampler t.fnt hello a
## ### ###
## ## ##
## ## ##
## ### ##### ## ## #####
## ## ## ## ## ## ## ## ##
#### #### ### ## ## ## ##
### ####### ## ## ## ##
## #### ## ## ## ##
## #### ## ## ## ## ##
## ## ###### ## ## #####
$ ./fntsampler t.fnt "Hello World!" > hello.pbm
$ display hello.pbm
L'immagine di esempio di tutti i caratteri sopra è stata creata da:
$ for f in *.fnt; do ./fntsampler "$f" "$(printf "%-6s Hello ABC abc 123" "$f")" | convert - "${f%.*}.png"; done
$ convert -negate -append *.png collection.png
Codice:
#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;
}