Onde posso encontrar uma versão moderna do tipo de console do “rock” (ou “t”)?

Nos dias Slackware e RedHat pré-Fedora, havia uma fonte de console chamada, às vezes, "rock" ou "t". Pesquisei isso muitas vezes, mas não consigo encontrar nenhuma referência a ele. Eu pensei que seria divertido trazê-lo de volta ao Ubuntu, se possível. Alguém sabe como seria chamado agora, ou se existe uma versão TrueType que eu poderia colocar em outros sistemas?

AFAIK não há portas existentes dessa fonte para nenhuma variante de estrutura de tópicos. No entanto, aqui estão alguns detalhes e hacks que podem ajudá-lo no caminho.

O t.fnt , Tektite, foi criado pelo (antigo?) ClySmic Software e provavelmente por Ralph B Smith Jr, Presidente / Programador Principal / Cook / Bottle Washer . É uma fonte de bitmap incluída no programa VFONT para DOS e OS / 2. Carrega fontes de substituição para sistemas VGA. O nome dado pelo autor é Tektite e é descrito como "uma fonte no estilo" Arquiteto "".

O VFONT pode ser baixado nos arquivos CVFONT.ZIP e CVFONTA.ZIP. A fonte Tektite faz parte deste último. A primeira é uma versão mais antiga apenas para o DOS.

VFONT e extração:

O arquivo consiste no programa DOS, VFONT.COM, programa OS / 2 VFONT2.EXE, um banco de dados de fontes VFONT.DAT e um README.MAN. O VFONT.DAT contém 13 fontes de bitmap armazenadas consecutivamente. Para extrair a fonte Tektite, faça:

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

Isso fornece um arquivo de fonte do tipo RAW, que é o incluído no, por exemplo, Slackware.

Cada fonte tem 4096 bytes. Assim, para extrair os outros, basta alterar a opção pular . Ou seja, o c.fntque vem depois t.fntfornece um valor de salto de 28672 + 4096 = 32768. Todas as fontes estão incluídas no Linux e, para fazer uma extração completa, é possível:

#!/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, é claro, faça o download de uma das várias distribuições que as inclui.

Esses arquivos podem ser carregados diretamente no terminal, por exemplo:

setfont t.fnt

Nomeando no Linux

A fonte recebeu seu nome no Linux pelas opções do programa VFONT. Tektite tem /T. As outras fontes também estão incluídas, também são nomeadas pela opção de linha de comando do VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... etc.)

Fontes RAW

O formato de fonte RAW (obsoleto, mas reconhecido) é o formato de fonte mais simples que existe. Ele não possui cabeçalho, rodapé, bytes de escape etc. Geralmente, possui uma largura de 8 pixels (bits) - assim como as fontes VFONT. Eles sempre têm 256 glifos.

A partir disso, podemos calcular facilmente a altura:

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

Como todas as fontes VFONT têm um tamanho de 4096, também sabemos que todas têm 16 pixels (bits) de altura. Isso também indica que cada glifo tem 16 bytes.

Renderização ASCII

Como as fontes estão em conformidade com o intervalo ASCII quando se trata de 0x20 (espaço) - 0x7e (til), podemos fazer uma renderização ASCII simples dos glifos.

Por exemplo, a letra Atem a posição 65. Como cada glifo é 8 × 16 = 128 bits, nós os temos em 128/8 = 16 bytes.

Como 65 × 16 = 1040, podemos extrair o glifo A(incluindo conversão para binário e substituição de 0 e 1 para torná-lo mais legível):

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

O que nos 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 um código C simples, também podemos renderizar imagens PBM simples. Aqui está um exemplo de saída de todas as fontes no VFONT:

Editando com FontForge

Se você deseja trabalhar com a fonte, acho que pode ir ao FontForge . Como ele não reconhece fontes RAW, é necessário convertê-lo para outro formato. Uma das conversões mais simples pode ser no BDF. Uma opção é usar as ferramentas PSF de John Elliot . Primeiro converta de RAW para PSF e depois PSF para BDF:

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

O arquivo BDF agora pode ser aberto no FontForge

Como o processo é bastante simples (e o mesmo para todos os VFONT), você também pode usar este script para converter diretamente no formato BDF:

Uso da amostra:

./raw2bdf Tektite t.fnt > t.bdf

Fornece a fonte 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"
    }
'

Outras versões

Existem várias versões modificadas da fonte Tektite. Se você procurá-lo, adicione opcionalmente, por exemplo, “clysmic” à frase de pesquisa em que você pode estudar.

Renderização de imagem

Para completar, adiciono o código C amassado para criar a imagem acima. displaye convertfazem parte do ImageMagick .

Uso da amostra:

$ ./fntsampler t.fnt hello a

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

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

A imagem de amostra de todas as fontes acima foi criada 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;
}