Wo finde ich eine moderne Version der Konsolenschrift "rock" (oder "t")?

In den Tagen von Slackware und RedHat vor Fedora gab es eine Konsolenschrift, die manchmal "rock" oder "t" genannt wurde. Ich habe schon oft danach gesucht, kann aber keinen Hinweis darauf finden. Ich dachte, es würde Spaß machen, es wenn möglich wieder auf Ubuntu zu bringen. Weiß jemand, wie es jetzt heißen würde, oder ob es eine TrueType-Version davon gibt, die ich auf andere Systeme übertragen könnte?

AFAIK Es gibt keine vorhandenen Ports dieser Schriftart für eine Gliederungsvariante. Hier sind jedoch einige Details und Hacks, die Ihnen auf dem Weg helfen könnten.

Das t.fnt , Tektite, wurde von der (ehemaligen?) ClySmic Software und wahrscheinlich von Ralph B. Smith Jr., Präsident / Chefprogrammierer / Koch / Flaschenwascher, erstellt . Es ist eine Bitmap-Schriftart, die im VFONT-Programm für DOS und OS / 2 enthalten war. Es werden Ersatzschriftarten für VGA-Systeme geladen. Der vom Autor angegebene Name ist Tektite und wird als Schriftart im "Architect" -Stil beschrieben.

VFont kann heruntergeladen im Archiv CVFONT.ZIP und CVFONTA.ZIP. Die Tektite- Schriftart ist Teil der letzteren. Ersteres ist eine ältere Version nur für DOS.

VFONT und Extraktion:

Das Archiv besteht aus dem DOS-Programm VFONT.COM, dem OS / 2-Programm VFONT2.EXE, einer Schriftdatenbank VFONT.DAT und einem README.MAN. Das VFONT.DAT enthält 13 Bitmap-Schriftarten, die hintereinander gespeichert werden. So extrahieren Sie die Tektite-Schriftart:

dd if=VFONT.DAT of=t.fnt bs=1 skip=28672 count=4096

Dadurch erhalten Sie eine Schriftartdatei vom Typ RAW, die beispielsweise in Slackware enthalten ist.

Jede Schriftart ist 4096 Bytes. Um die anderen zu extrahieren, ändern Sie einfach die Überspringoption . Dh c.fntwas danach kommt t.fntgibt dir einen Sprungwert von 28672 + 4096 = 32768. Alle Schriftarten sind in Linux enthalten, und um eine vollständige Extraktion durchzuführen, kann man Folgendes tun:

#!/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

... oder natürlich von einer der verschiedenen Distributionen herunterladen, die sie enthalten.

Diese Dateien können direkt in das Terminal geladen werden, z.

setfont t.fnt

Benennung unter Linux

Die Schriftart wurde unter Linux durch die Optionen für das VFONT-Programm benannt. Tektit hat /T. Die anderen Schriftarten sind ebenfalls enthalten und werden ebenfalls durch die Befehlszeilenoption für VFONT benannt. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... usw.)

RAW-Schriftarten

Das (veraltete, aber erkannte) RAW-Schriftformat ist das einfachste Schriftformat, das es gibt. Es hat keine Kopf- und Fußzeile, keine Escape-Bytes usw. Es hat normalerweise eine Breite von 8 Pixel (Bits) - genau wie die VFONT-Schriftarten. Sie haben immer 256 Glyphen.

Daraus können wir die Höhe leicht berechnen durch:

      file_size (bits)               8 × 4096
h = -------------------- e.g.  h = ------------- = 16
          w × 256                    8 × 256

Da alle VFONT-Schriftarten eine Größe von 4096 haben, wissen wir auch, dass sie alle 16 Pixel (Bit) hoch sind. Das bedeutet auch, dass jede Glyphe 16 Bytes umfasst.

ASCII-Rendering

Da die Schriftarten dem ASCII-Bereich entsprechen, wenn es um 0x20 (Leerzeichen) - 0x7e (Tilde) geht, können wir die Glyphen einfach in ASCII rendern.

Zum Beispiel hat der Buchstabe APosition 65. Da jede Glyphe 8 × 16 = 128 Bit ist, haben wir sie bei 128/8 = 16 Bytes.

Als 65 × 16 = 1040 können wir die Glyphe extrahieren Adurch (hier einschließlich Konvertierung in Binär und Ersetzen von Nullen und Einsen, um sie besser lesbar zu machen):

xxd -s 1040 -l 16 -b -c 1 t.fnt | cut -d' ' -f 2 | tr 0 ' ' | tr 1 '#'

Was uns gibt:

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

Mit einem einfachen C-Code können wir auch einige einfache PBM-Bilder rendern. Hier ist eine Beispielausgabe aller Schriftarten in VFONT:

Bearbeiten mit FontForge

Wenn Sie mit der Schriftart arbeiten möchten, gehen Sie wahrscheinlich zu FontForge . Da RAW-Schriftarten nicht erkannt werden, müssen Sie sie in ein anderes Format konvertieren. Eine der einfacheren Konvertierungen könnte in BDF erfolgen. Eine Möglichkeit ist die Verwendung der PSF-Tools von John Elliot . Zuerst von RAW zu PSF konvertieren, dann von PSF zu BDF:

raw2psf t.fnt t.psf
psf2bdf t.psf t.bdf

Die BDF-Datei kann jetzt in FontForge geöffnet werden

Da der Vorgang ziemlich einfach ist (und für alle VFONTs gleich ist), können Sie dieses Skript auch verwenden, um direkt in das BDF-Format zu konvertieren:

Beispielnutzung:

./raw2bdf Tektite t.fnt > t.bdf

Gibt Ihnen die Tektite-Schriftart als 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"
    }
'

Andere Versionen

Es gibt mehrere modifizierte Versionen der Tektite-Schriftart. Wenn Sie danach suchen, fügen Sie dem Suchbegriff, den Sie studieren können , optional z. B. "clysmic" hinzu .

Bildwiedergabe

Der Vollständigkeit halber füge ich den C-Code hinzu, der zusammengesetzt ist, um das obige Bild zu erstellen. displayund convertsind Teil von ImageMagick .

Beispielnutzung:

$ ./fntsampler t.fnt hello a

##                ###     ###           
##                 ##      ##           
##                 ##      ##           
##  ###   #####    ##      ##     ##### 
## ## ## ##   ##   ##      ##    ##   ##
####  ####  ###    ##      ##   ##    ##
###   #######      ##      ##   ##    ##
##    ####         ##      ##   ##    ##
##    ####    ##   ##      ##   ##   ## 
##    ## ######    ##      ##    #####  

$ ./fntsampler t.fnt "Hello World!" > hello.pbm
$ display hello.pbm

Das Beispielbild aller oben genannten Schriftarten wurde erstellt von:

$ for f in *.fnt; do ./fntsampler "$f" "$(printf "%-6s Hello ABC abc 123" "$f")" | convert - "${f%.*}.png"; done

$ convert -negate -append *.png collection.png

Code:

#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;
}