Où puis-je trouver une version moderne de la police de caractère «rock» (ou «t»)?

À l'époque Slackware et RedHat-avant Fedora, il y avait une police de console appelée, parfois, "rock" ou "t". J'ai cherché cela plusieurs fois, mais je n'y trouve aucune référence. Je pensais que ce serait amusant de le ramener sur Ubuntu, si possible. Quelqu'un sait-il comment il s'appellerait maintenant, ou s'il existe une version TrueType que je pourrais mettre sur d'autres systèmes?

AFAIK il n'y a aucun port existant de cette police vers une variante de contour. Voici cependant quelques détails et astuces qui pourraient vous aider sur le chemin.

Le t.fnt , Tektite, a été créé par (l'ancien?) ClySmic Software et probablement Ralph B Smith Jr, président / programmeur en chef / cuisinier / laveur de bouteilles . Il s'agit d'une police bitmap incluse avec le programme VFONT pour DOS et OS / 2. Il charge les polices de remplacement pour les systèmes VGA. Son nom donné par l'auteur est Tektite et décrit comme «une police de style« Architecte ».»

VFONT peut être téléchargé dans les archives CVFONT.ZIP et CVFONTA.ZIP. La police Tektite fait partie de cette dernière. Le premier est une ancienne version uniquement pour DOS.

VFONT et extraction:

L'archive comprend le programme DOS, VFONT.COM, le programme OS / 2 VFONT2.EXE, une base de données de polices VFONT.DAT et un fichier README.MAN. Le VFONT.DAT contient 13 polices bitmap stockées dos à dos. Pour extraire la police Tektite, procédez comme suit:

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

Cela vous donne un fichier de police de type RAW, qui est celui inclus par exemple dans Slackware.

Chaque police fait 4096 octets. Ainsi, pour extraire les autres, changez simplement l' option de saut . C'est-à-dire c.fntqui vient après t.fntvous donne une valeur de saut de 28672 + 4096 = 32768. Toutes les polices sont incluses dans Linux, et pour faire une extraction complète, on pourrait faire:

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

... ou bien sûr, téléchargez-le à partir de l'une des différentes distributions qui les incluent.

Ces fichiers peuvent être chargés directement dans le terminal par exemple:

setfont t.fnt

Nommer sous Linux

La police a été nommée sous Linux par les options du programme VFONT. Tektite l'a fait /T. Les autres polices sont également incluses, sont également nommées par l'option de ligne de commande pour VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... etc.)

Polices RAW

Le format de police RAW (obsolète mais reconnu) est le format de police le plus simple qui soit. Il n'a pas d'en-tête, pas de pied de page, pas d'octets d'échappement, etc. Il a généralement une largeur de 8 pixels (bits) - tout comme les polices VFONT. Ils ont toujours 256 glyphes.

À partir de cela, nous pouvons facilement calculer la hauteur en:

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

Comme toutes les polices VFONT ont une taille de 4096, nous savons également qu'elles ont toutes une hauteur de 16 pixels (bits). Cela donne également que chaque glyphe fait 16 octets.

Rendu ASCII

Comme les polices sont conformes à la plage ASCII en ce qui concerne 0x20 (espace) - 0x7e (tilde), nous pouvons effectuer un rendu ASCII simple des glyphes.

Par exemple, la lettre Aa la position 65. Comme chaque glyphe est 8 × 16 = 128 bits, nous les avons à 128/8 = 16 octets.

Comme 65 × 16 = 1040, nous pouvons extraire le glyphe Apar (ici, y compris la conversion en binaire et le remplacement des 0 et des 1 pour le rendre plus lisible):

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

Ce qui nous donne:

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

En utilisant un simple code C, nous pouvons également rendre des images PBM simples. Voici un exemple de sortie de toutes les polices dans VFONT:

Modification avec FontForge

Si vous souhaitez travailler avec la police, je suppose que vous pouvez aller à FontForge . Comme il ne reconnaît pas les polices RAW, vous devez le convertir dans un autre format. L'une des conversions les plus simples pourrait être BDF. Une option consiste à utiliser les outils PSF de John Elliot . Convertissez d'abord de RAW en PSF puis PSF en BDF:

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

Le fichier BDF peut maintenant être ouvert dans FontForge

Comme le processus est assez simple (et identique pour tous les VFONT), vous pouvez également utiliser ce script pour convertir directement au format BDF:

Exemple d'utilisation:

./raw2bdf Tektite t.fnt > t.bdf

Vous donne la police Tektite en tant que 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"
    }
'

Autres versions

Il existe plusieurs versions modifiées de la police Tektite. Si vous le recherchez, ajoutez éventuellement «clysmic» à la phrase de recherche sur laquelle vous pouvez étudier.

Rendu d'image

Par souci d'exhaustivité, j'ajoute le code C en purée pour créer l'image ci-dessus. displayet convertfont partie d' ImageMagick .

Exemple d'utilisation:

$ ./fntsampler t.fnt hello a

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

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

L'image d'exemple de toutes les polices ci-dessus a été créée par:

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