¿Dónde puedo encontrar una versión moderna del tipo de letra de la consola "rock" (o "t")?

En los días de Slackware y RedHat-pre-Fedora, había una fuente de consola llamada, a veces, "rock" o "t". He buscado esto muchas veces, pero no puedo encontrar ninguna referencia. Pensé que sería divertido traerlo de vuelta a Ubuntu, si es posible. ¿Alguien sabe cómo se llamaría ahora, o si hay una versión TrueType de él que podría poner en otros sistemas?

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