Como os computadores exibem texto e gráficos brutos e de baixo nível

Meu interesse cada vez maior por computadores está me fazendo fazer perguntas mais profundas, que parece que não precisamos mais fazer. Nossos computadores, na inicialização, tanto quanto eu o entendo, estão no modo de texto , no qual um caracter pode ser exibido usando o software 0x10quando AH=0x0e. Todos nós vimos a famosa fonte de inicialização que sempre parece a mesma, independentemente do computador que está inicializando.

Então, como diabos os computadores produzem gráficos no nível mais baixo, por exemplo, abaixo do sistema operacional? E também, certamente os gráficos não produzem um pixel de cada vez usando interrupções de software, pois isso soa muito lento?

Existe um padrão que define a saída básica de vértices, polígonos, fontes etc. (abaixo do OpenGL, por exemplo, qual OpenGL pode usar)? O que me faz perguntar é por que os SOs geralmente podem ficar bem sem os drivers oficiais instalados; como eles fizeram isso?

Desculpas se minhas suposições estão incorretas. Ficaria muito grato pela elaboração desses tópicos!

Esse é (parcialmente) o papel do BIOS.

O sistema básico de entrada e saída do computador é responsável por fornecer uma interface comum para os sistemas operacionais, apesar das diferenças entre os computadores reais.

Dito isto, para gráficos especificamente, existem diferentes maneiras de desenhar na tela. Existem comandos TTY que você pode enviar para o BIOS, mas isso é apenas no modo real. Se você quiser desenhar qualquer coisa no modo protegido, precisará usar o VGA para desenhar. Não posso explicar melhor do que o OSDev, portanto, procure aqui mais informações - mas, basicamente, você pode gravar na memória (a memória de vídeo é mapeada na memória) começando no endereço 0xB8000para desenhar as coisas na tela.

Se você precisar de uma resolução mais alta que a VGA, precisará usar as extensões do BIOS VESA; Não estou familiarizado com isso, mas tente consultar o código-fonte do GRUB para obter mais informações.

Algumas referências úteis:

• Código fonte do GRUB :

  grub-core/video/i386/pc/vbe.c
  grub-core/video/i386/pc/vga.c
  

• Wiki do OSDev (desenho no modo protegido)

• Extensões de BIOS VESA

Se você está familiarizado com o D - escrevi um pequeno carregador de inicialização há algum tempo atrás, capaz de gravar na tela (somente texto). Se você estiver interessado, aqui está o código:

align(2) struct Cell { char ch; ubyte flags = 0x07; }

@property Cell[] vram()
{ return (cast(Cell*)0xB8000)[0 .. CONSOLE_WIDTH * CONSOLE_HEIGHT]; }

void putc(char c)
{
    if (isBochs) { _outp(0xE9, c); }  // Output to the Bochs terminal!

    bool isNewline = c == '\n';
    while (cursorPos + (isNewline ? 0 : 1) > vram.length)
    {
        for (short column = CONSOLE_WIDTH - 1; column >= 0; column--)
        {
            foreach (row; 0 .. CONSOLE_HEIGHT - 1)
            {
                uint cell = column + cast(uint)row * CONSOLE_WIDTH;
                vram[cell] = vram[cell + CONSOLE_WIDTH];
            }
            vram[column + (CONSOLE_HEIGHT - 1) * CONSOLE_WIDTH].ch = ' ';
        }
        cursorPos = cast(ushort)(cursorPos - CONSOLE_WIDTH);
    }
    if (isNewline)
        cursorPos = cast(ushort)
            ((1 + cursorPos / CONSOLE_WIDTH) * CONSOLE_WIDTH);
    else vram[cursorPos++].ch = c;
}

void putc(char c, ubyte attrib) { vram[cursorPos] = Cell(c, attrib); }

void memdump(void* pMem, size_t length)
{
    foreach (i; 0 .. length)
        putc((cast(char*)pMem)[i]);
}

void clear(char clear_to = '\0', ubyte attrib = DEFAULT_ATTRIBUTES)
{
    foreach (pos; 0 .. vram.length)
        vram[pos] = Cell(clear_to, attrib);
    cursorPos = 0;
}

@property ushort cursorPos()
{
    ushort result = 0;
    _outp(0x3D4, 14);
    result += _inp(0x3D5) << 8;
    _outp(0x3D4, 15);
    result += _inp(0x3D5);
    return result;
}

@property void cursorPos(ushort position)
{
    _outp(0x3D4, 14);
    _outp(0x3D5, (position >> 8) & 0xFF);
    _outp(0x3D4, 15);
    _outp(0x3D5, position & 0xFF);
}

Desde os primórdios do IBM PC e de seus clones, o hardware do adaptador de vídeo era muito simples: um pequeno bloco de memória era dedicado a uma grade de células de caracteres (80x25 caracteres no modo padrão), com dois bytes de memória para cada célula . Um byte selecionou o caractere e o outro selecionou seus "atributos" - cores de primeiro e segundo plano, além de controle de piscada para adaptadores de cores; vídeo em negrito, sublinhado, piscando ou reverso para adaptadores monocromáticos. O hardware procurou pixels em uma tabela ROM de formas de caracteres de acordo com o conteúdo da memória de caracteres.

Para oferecer um certo grau de independência de hardware, a interface do BIOS para o mapa de caracteres exigia a execução de uma interrupção do software para definir uma célula de caractere na tela. Isso foi lento e ineficiente. No entanto, a memória de caracteres também era endereçável diretamente pela CPU; portanto, se você soubesse qual hardware estava presente, poderia escrever diretamente na memória. De qualquer maneira, uma vez definido, o caractere permaneceria na tela até ser alterado, e a memória total de caracteres com a qual você precisava trabalhar era de 4000 bytes - aproximadamente o tamanho de uma única textura de 32x32 em cores!

Nos modos gráficos, a situação era semelhante; cada pixel na tela está associado a um local específico na memória, e havia uma interface de conjunto de pixels do BIOS, mas o trabalho de alto desempenho exigia a gravação direta na memória. Padrões posteriores, como o VESA, permitem que o sistema faça algumas consultas lentas com base no BIOS para aprender o layout da memória do hardware e, em seguida, trabalhar diretamente com a memória. É assim que um sistema operacional pode exibir gráficos sem um driver especializado, embora os sistemas operacionais modernos também incluam drivers básicos para o hardware de todos os principais fabricantes de GPUs. Até a mais nova placa NVidia suporta vários modos de compatibilidade com versões anteriores, provavelmente desde o IBM CGA.

Uma diferença importante entre gráficos 3D e 2D é que, em 2D, geralmente não é necessário redesenhar a tela inteira a cada quadro. Em 3D, se a câmera se mover um pouquinho, todos os pixels na tela poderão mudar; em 2D, se você não estiver rolando, a maior parte da tela permanecerá inalterada quadro a quadro, e mesmo se estiver rolando, geralmente é possível fazer uma cópia rápida de memória em memória em vez de recompor a cena inteira. Portanto, não é nada como ter que executar INT 10h para cada pixel em cada quadro.

Fonte: Eu sou muito velho

Durante a inicialização, o BIOS do sistema procura o adaptador de vídeo. Em particular, ele procura o programa BIOS embutido no adaptador de vídeo e o executa. Este BIOS é normalmente encontrado no local C000h na memória. O BIOS do sistema executa o BIOS de vídeo , que inicializa o adaptador de vídeo.

Quais níveis ou modos de vídeo / gráficos o BIOS pode exibir nativamente, sem um SO ou drivers, depende principalmente do próprio BIOS de vídeo.

Fonte / Mais informações aqui - "Sequência de inicialização do sistema"

Nossos computadores, na inicialização, até onde eu entendi, estão no modo de texto, no qual um caractere pode ser exibido usando o software interrompe 0x10 quando AH = 0x0e

Você está falando sobre funções herdadas do BIOS. Na verdade, você não precisa usar essas funções. Você os escreve diretamente na memória de vídeo.

como diabos os computadores produzem gráficos no nível mais baixo, digamos, abaixo do sistema operacional?

Isso tem a ver com a maneira como o sistema operacional opera. De qualquer forma, a operação é a mesma no nível do hardware: a placa de vídeo possui uma RAM de vídeo, que armazena (simplificando) a próxima imagem a ser desenhada na tela. Você pode pensar que cada endereço é um byte que representa um pixel (na verdade geralmente você precisa de mais de um byte por pixel). Em seguida, o controlador de vídeo se encarrega de traduzir isso em um sinal que o monitor entende.

Existe um padrão que define a saída básica de vértices, polígonos, fontes etc. (abaixo do OpenGL, por exemplo, qual OpenGL pode usar)?

AFAIK, não. Não há padrões sobre representações gráficas lógicas.

O que me faz perguntar é por que os SOs geralmente podem ficar bem sem os drivers oficiais instalados; como eles fizeram isso?

Porque ele já possui drivers incluídos no sistema operacional.