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

8

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

    
por David Krider 31.08.2015 / 15:02

1 resposta

19

AFAIK não há portas existentes desta fonte para nenhuma variante de contorno. 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 Ralph B Smith Jr, Presidente / Programador Chefe / Cozinheiro / Lavador de Garrafas . É uma fonte de bitmap que foi incluída com o programa VFONT para DOS e OS / 2. Ele carrega fontes de substituição para sistemas VGA. Seu nome dado pelo autor é Tektite e descrito como ”uma fonte estilo" Arquiteto ".

O VFONT pode ser baixado nos arquivos CVFONT.ZIP e CVFONTA.ZIP. A fonte Tektite é parte da última. O primeiro é uma versão mais antiga apenas para o DOS.

VFONT e extração:

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

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 em, e. Slackware

Cada fonte é 4096 bytes. Assim, para extrair os outros, basta alterar a opção ignorar . Ou seja c.fnt que vem depois de t.fnt fornece um valor de pulo 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 distros que os incluem.

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

setfont t.fnt

Nomeação 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 para o VFONT. ( / S = s.fnt, / SD = sd.fnt, / RO = ro.fnt ... etc.)

Fontes RAW

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

Com isso, podemos calcular facilmente a altura por:

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

Como todas as fontes VFONT possuem um tamanho de 4096, também sabemos que elas têm 16 pixels (bits) de altura. Isso também dá a cada glifo 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 simples renderização ASCII dos glifos.

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

Como 65 × 16 = 1040, podemos extrair o glifo A (incluindo aqui a conversão para binário e a 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 algum código C simples, também podemos renderizar algumas imagens simples de PBM. Aqui está um exemplo de saída de todas as fontes no VFONT:

EditandocomFontForge

Sevocêdesejatrabalharcomafonte,euachoquevocêpodeirparaFontForge.ComoelenãoreconhecefontesRAW,énecessárioconvertê-loemoutroformato.UmadasconversõesmaissimplespoderiaseraBDF.Umaopçãoéusar Ferramentas do PSF de John Elliot . Primeiro converta do RAW ao PSF então PSF ao 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's), você também pode usar este script para converter diretamente para o 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ê pesquisar por ele, opcionalmente adicionando "clysmic" para a frase de pesquisa que você pode estudar.

Renderização de imagem

Para completar, adiciono o código C mashed para criar a imagem acima. display e convert fazem parte do ImageMagick .

Uso da amostra:

$ ./fntsampler t.fnt hello a

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

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

Aimagemdeamostradetodasasfontesacimafoicriadapor:

$forfin*.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;
}
    
por 06.09.2015 / 00:26

Tags