| Tutorial de Assembler de Adam Hyde 1.0 PARTE 6 Traduzido por Renato Nunes Bastos |
Versão: 1.1 Data: 13-04-1996 / online by Renato 03-11-1998
Contato: blackcat@vale.faroc.com.au
http://www.faroc.com.au/~blackcat
;Renato: Contato
http://www.geocities.com/SiliconValley/Park/3174 (meu site antigo, agora está fora do ar)
http://www.krull.com.br
Introdução / Rotina do último tutorial | In e Out | Mais Flags
Olá de novo, programadores de Assembler. Esta edição demorou um pouco, mas eu tinha muita coisa para terminar, e eu estou trabalhando em um jogo meu agora. É um jogo de estratégia, como Warlords II, e acho que eu vou ter que escrever a maior parte do código em 640×480, não meu amado 320×200 – mas eu posso mudar de idéia. Eca, a quantidade de jogos que eu comecei a escrever mas nunca cheguei a terminar é enorme, e este não deve chegar muito longe. De qualquer modo, eu disse que daríamos uma olhada numas rotinas de linha e círculo esta semana, então, vamos lá…
Semana passada nós chegamos à seguinte rotina de linhas horizontais:
mov ax, 0A000h mov es, ax ; Aponta ES para a VGA mov ax, x1 ; AX = X1 mov bx, y ; BX = Y mov cx, x2 ; CX = X2 sub cx, ax ; CX = Diferença de X2 e X1 mov di, ax ; DI = X1 mov dx, bx ; DX = Y shl bx, 8 ; Y SHL 8 shl dx, 6 ; Y SHL 6 add dx, bx ; DX = Y SHL 8 + Y SHL 6 add di, dx ; DI = Offset do primeiro pixel mov al, color ; Põe a cor a plotar em AL rep stosb ; Desenha a linha
Agora, embora essa rotina seja muito mais rápida que as rotinas do BGI, (ou seja lá o que for que seu compilador tenha), ela poderia ser melhorada pra caramba. Se entrarmos na rotina, com a lista de clocks que eu dei no último tutorial, você vai ver que ela gasta bem pouco. Eu vou deixar a otimização com você por enquanto, (vamos ver isso em outro tutorial), mas se substituir STOSB por MOV ES:[DI], AL ou STOSW vai melhorar muito as coisas. Não se esqueça que se você decidir usar um loop, para jogar words na VGA, você terá que decrementar CX de uma unidade. Agora, vamos ver uma linha vertical. Teremos que calcular o offset do primeiro pixel como nós fizemos na rotina de linhas horizontais, então, algo desse tipo funcionaria:
mov ax, 0A000h ; Põe o segmento VGA em AX mov es, ax ; Aponta ES para a VGA mov ax, Y1 ; Move o primeiro valor de Y para AX shl ax, 6 ; Y x 26 mov di, ax ; Move o novo valor de Y para DI shl ax, 2 ; Agora temos Y = Y x 320 add di, ax ; Adiciona aquele valor a DI add di, X ; Soma o valor de X a DI
Agora umas coisas básicas…
mov cx, Y2 ; Guarda Y2 em CX mov al, Color ; Guarda a cor a plotar em AL sub cx, Y1 ; CX = tamanho da linha
E agora o loop final…
Plota: mov es:[di], al ; Põe um pixel no offset corrente add di, 320 ; Move para a próxima linha dec cx ; Decrementa CX de um jnz Plota ; Se CX <> 0, então continua plotando
Não é uma rotina fantástica, mas é muito boa. Note como foi possível realizar uma comparação depois de DEC CX. Isto é um conceito extremamente útil, logo, não se esqueça de que isso é possível.
Brinque um pouco com o código, e tente fazê-lo mais rápido. Tente outros métodos de calcular o offset, ou métodos diferentes de controle de fluxo.
Agora, isso foi a coisa fácil. Vamos ver agora uma rotina capaz de desenhar linhas diagonais.
A seguinte rotina foi tirada de SWAG, autor desconhecido, e é uma rotina ideal para demonstrar um algoritmo de linhas. Ele está precisando muito de uma otimização, assim, essa pode ser uma tarefa para você – se você quiser. Alguns dos pontos a considerar são:
- Seja lá quem o escreveu nunca ouviu falar de XCHG – isso economizaria alguns clocks;
- Ele comete um dos grandes pecados do código não-otimizado – ele move um valor para AX, e então realiza uma operação envolvendo AX na próxima instrução, assim fazendo um ciclo a mais. (Vamos falar sobre isso semana que vem).
- Ele trabalha com BYTES e não WORDS, assim, a velocidade de escrita para a VGA poderia se dobrada se usasse words.
- E o maior pecado de todos, ele usa um MUL para achar o offset. Tente usar shifts ou um XCHG para acelerar as coisas.
De qualquer modo, eu pus os comentários nele, e acho que ele é auto-explicativo, assim, eu não vou entrar em detalhes como ele funciona. Você deve ser capaz de pegar isso sozinho. Adentre a rotina, e veja como a derivada (gradiente, variação, inclinação…) da linha foi calculada.
Procedure Line(X1,Y1, X2, Y2 : Word; Color : Byte); Assembler;
Var
DeX : Integer;
DeY : Integer;
IncF : Integer;
Asm { Line }
mov ax, [X2] { Move X2 para AX }
sub ax, [X1] { Pega o tamanho horizontal da linha (X2 - X1) }
jnc @Dont1 { X2 - X1 é negativo? }
neg ax { Sim, então faz com que seja positivo }
@Dont1:
mov [DeX], ax { Agora, move o tamanho horizontal da linha para DeX }
mov ax, [Y2] { Move Y2 para AX }
sub ax, [Y1] { Subtrai Y1 de Y2, dando o tamanho vertical }
jnc @Dont2 { Foi negativo? }
neg ax { Sim, então faça-o positivo }
@Dont2:
mov [DeY], ax { Move o tamanho vertica para DeY }
cmp ax, [DeX] { Compara o tamanho vertivcal com o horizontal }
jbe @OtherLine { Se o vertical foi <= horizontal então pula }
mov ax, [Y1] { Move Y1 para AX }
cmp ax, [Y2] { Compara Y1 a Y2 }
jbe @DontSwap1 { Se Y1 <= Y2 então pula, senão... }
mov bx, [Y2] { Põe Y2 em BX }
mov [Y1], bx { Põe Y2 em Y1 }
mov [Y2], ax { Move Y1 para Y2 }
{ Para que depois de tudo isso..... }
{ Y1 = Y2 e Y2 = Y1 }
mov ax, [X1] { Põe X1 em AX }
mov bx, [X2] { Põe X2 em BX }
mov [X1], bx { Põe X2 em X1 }
mov [X2], ax { Põe X1 em X2 }
@DontSwap1:
mov [IncF], 1 { Põe 1 em IncF, i.e., plota outro pixel }
mov ax, [X1] { Põe X1 em AX }
cmp ax, [X2] { Compara X1 com X2 }
jbe @SkipNegate1 { Se X1 <= X2 então pula, senão... }
neg [IncF] { Nega IncF }
@SkipNegate1:
mov ax, [Y1] { Move Y1 para AX }
mov bx, 320 { Move 320 para BX }
mul bx { Multiplica 320 por Y1 }
mov di, ax { Põe o resultado em DI }
add di, [X1] { Soma X1 a DI, e tcham - offset em DI }
mov bx, [DeY] { Põe DeY em BX }
mov cx, bx { Põe DeY em CX }
mov ax, 0A000h { Põe o segmento a ser plotado, em AX }
mov es, ax { ES aponta para a VGA }
mov dl, [Color] { Põe a cor a usar em DL }
mov si, [DeX] { Aponta SI para DeX }
@DrawLoop1:
mov es:[di], dl { Põe a cor a plotar, DL, em ES:DI }
add di, 320 { Soma 320 a DI, i.e., próxima linha abaixo }
sub bx, si { Subtrai DeX de BX, DeY }
jnc @GoOn1 { Ficou negativo? }
add bx, [DeY] { Sim, então soma DeY a BX }
add di, [IncF] { Soma a quantidade a incrementar a DI }
@GoOn1:
loop @DrawLoop1 { Nenhum resultado negativo, então plota outro pixel }
jmp @ExitLine { Acabou, então vamos embora! }
@OtherLine:
mov ax, [X1] { Move X1 para AX }
cmp ax, [X2] { Compara X1 a X2 }
jbe @DontSwap2 { X1 <= X2 ? }
mov bx, [X2] { Não, então move X2 para BX }
mov [X1], bx { Move X2 para X1 }
mov [X2], ax { Move X1 para X2 }
mov ax, [Y1] { Move Y1 para AX }
mov bx, [Y2] { Move Y2 para BX }
mov [Y1], bx { Move Y2 para Y1 }
mov [Y2], ax { Move Y1 para Y2 }
@DontSwap2:
mov [IncF], 320 { Move 320 para IncF, i.e., o próximo pixel está na }
{ próxima linha }
mov ax, [Y1] { Move Y1 para AX }
cmp ax, [Y2] { Compara Y1 a Y2 }
jbe @SkipNegate2 { Y1 <= Y2 ? }
neg [IncF] { Não, então nega IncF }
@SkipNegate2:
mov ax, [Y1] { Move Y1 para AX }
mov bx, 320 { Move 320 para BX }
mul bx { Multiplica AX por 320 }
mov di, ax { Move o resultado para DI }
add di, [X1] { Soma X1 a DI, dando o offset }
mov bx, [DeX] { Move DeX para BX }
mov cx, bx { Move BX para CX }
mov ax, 0A000h { Move o endereço da VGA para AX }
mov es, ax { Aponta ES para a VGA }
mov dl, [Color] { Move a cor a plotar para DL }
mov si, [DeY] { Move DeY para SI }
@DrawLoop2:
mov es:[di], dl { Põe o byte em DL para ES:DI }
inc di { Incrementa DI de um, o próximo pixel }
sub bx, si { Subtrai SI de BX }
jnc @GoOn2 { Ficou negativo? }
add bx, [DeX] { Sim, então soma DeX a BX }
add di, [IncF] { Soma IncF a DI }
@GoOn2:
loop @DrawLoop2 { Continua plotando }
@ExitLine:
{ Pronto! }
End;
Acho que não fiz nenhum erro com os comentários, mas eu estou bem cansado, e não tenho bebido cafeína há dias – se você encontrar um erro – por favor me diga.
Eu ia colocar um algoritmo de círculo, mas eu não consegui fazer a minha funcionar em Assembler – toda aquela matemática de ponto flutuante deve ter algo a ver com isso. Eu poderia incluir uma escrita em linguagem de alto nível, mas eu suponho que esse seja um tutorial de Assembler, não de gráficos. Contudo, se bastante pessoas reclamarem, querendo uma…
IN e OUT são uma parte muito importante de código em Assembler. Elas permitem você a
mandar/receber diretamente dados de qualquer uma das 65,536 portas de hardware, ou
registradores. A sintaxe básica é como segue:
- IN <ACUMULADOR>, <PORTA>
- Nome: Entrada de porta de E/S
- Tipo: 8086+
Descrição: Esta instrução lê um valor de uma das 65536 portas de hardware para o acumulador especificado. AX e AL são comumente usados para portas de entrada, e DX é mais usado para identificar a porta.
EX.:
IN AX, 72h
MOV DX, 3C7h
IN AL, DX
- OUT <PORTA>, <ACUMULADOR>
- Nome: Saída para a Porta
- Tipo: 8086+
Descrição: Esta instrução põe na saída o valor no acumulador para <PORTA>. Usando o registrador DX para passar a porta para OUT, você pode acessar até 65,536 portas.
EX.:
MOV DX, 378h
OUT DX, AX
OK, isso não ajudou muito, já que não disse muito sobre como usar – muito menos para quê usar. Bem, se você pretende trabalhar muito com a VGA, você terá que ser capaz de programar seus registradores internos. Semelhantes aos registradores com que você tem trabalhado até agora, você pode pensar em mudá-los como interrupções, exceto que: 1) Você passa os valores para a porta, e é isso aí; e 2) É muito perto de ser instantâneo.
Como exemplo, vamos ver como setar e pegar a palette controlando diretamente o hardware da VGA.
Agora, a VGA tem uma porção de registradores, mas as próximas três é bom que você conheça bem:
- 03C7h – PEL Registrador de Endereços (Leitura) – Seta a palette em modo de leitura
- 03C8h – PEL Registrador de Endereços (Escrita) – Seta a palette em modo de escrita
- 03C9h – PEL Registrador de Dados (Leitura/Escrita) – Lê, ou escreve 3 valores RGB, a cada terceira escrita, o índice, ou cor que você está setando, é incrementado de um.
O que tudo isso significa é:
Se nós fôssemos setar um valor RGB de uma cor RGB, nós mandaríamos o valor da cor que queríamos mudar para 03C8h, então ler os 3 valores de 03C9h. Em Assembler, faríamos isso:
mov dx, 03C8h ; Põe o registrador DAC de leitura em DX mov al, [Color] ; Põe o valor da cor em AL out dx, al ; Manda AL para a porta DX inc dx ; Agora usa a porta 03C9h mov al, [R] ; Põe o novo valor VERMELHO em AL out dx, al ; Manda AL para a porta DX mov al, [G] ; Põe o novo valor VERDE em AL out dx, al ; Manda AL para a porta DX mov al, [B] ; Põe o novo valor AZUL em AL out dx, al ; Manda AL para a porta DX
E aquilo deveria fazer a coisas direitinho. Para ler a palette, faríamos isso:
mov dx, 03C7h ; Põe o registrador DAC de escrita em DX mov al, [Color] ; Põe o valor da cor em AL out dx, al ; Manda AL para a porta DX add dx, 2 ; Agora usa a porta 03C9h in al, dx ; Põe o valor conseguido da porta DX em AL les di, [R] ; Aponta DI para a variável R - Isso vem do Pascal stosb ; Guarda AL em R in al, dx ; Põe o valor obtido da porta DX em AL les di, [G] ; Aponta DI para a variável G stosb ; Guarda AL em G in al, dx ; Põe o valor obtido da porta DX em AL les di, [B] ; Aponta DI para a variável B stosb ; Guarda AL em B
Note como essa rotina foi codificada diferentemente. Isso era originalmente uma rotina em Pascal, e como o Pascal não gosta que você mexa com variáveis de Pascal em Assembler, você tem que improvisar.
Se você está trabalhando com Assembler puro, então você pode codificar isso muito mais eficientemente, como o primeiro exemplo. Eu deixei o código como estava para que aqueles trabalhando com uma linguagem de alto nível possam chegar a um problema particularmente irritante.
Agora você já viu como IN e OUT podem ser úteis. Controlar diretamente o hardware é mais rápido e mais eficiente. Nas próximas semanas, eu posso incluir uma lista das portas mais comuns, mas se você tivesse uma cópia da Ralf Brown’s Interrupt List (disponível no X2FTP), você já teria uma cópia.
OBS.: Você pode achar um link para a Ralf Brown’s Interrupt List na minha página.
Um pouco mais sobre o registrador de flags:
Agora, embora tenhamos usado o registrador de flags em quase todo nosso código até esse ponto, eu não entrei profundamente nesse assunto. Você pode trabalhar felizmente sem conhecer muito sobre os flags, e comparar coisas sem saber o que está realmente acontecendo, mas se você quiser avançar no Assembler, você precisa saber algo mais.
De volta ao Tutorial Três, eu dei uma visão simplista do registrador de FLAGS. Na realidade, os FLAGS, ou EFLAGS é na verdade um registrador de 32-bit, embora apenas só os bits de 0 a 18 sejam usados. Na realidade não precisamos conhecer os flags acima do 11 por enquanto, mas é bom saber que eles existem.
O registrador EFLAGS, na verdade, se parece com isso:
18 17 16 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 AC VM RF -- NT IO/PL OF DF IF TF SF ZF -- AF -- PF -- CF
Agora, os flags são os seguintes:
- AC – Alignment Check (80486) / Checagem de Alinhamento
- VM – Virtual 8086 Mode / Modo Virtual 8086
- RF – Resume Flag / Flag de Continuação
- NT – Nested Task Flag / Flag de Tarefa Aninhada
- IOPL – I/O Privilege Level / Nível de Privilégio de E/STem um valor de 0,1,2 ou 3. Logo, ocupa 2 bits
- OF – Overflow Flag / Flag de OverflowEste bit é setado para UM se uma instrução aritmética gerar um resultado que seja muito grande ou muito pequeno para caber no registrador destino.
- DF – Direction Flag / Flag de DireçãoQuando setado para ZERO, as instruções de string, como MOVS, LODS,e STOS incrementarão o endereço de memória que elas estão trabalhando de uma unidade. Isto significa que, digamos, DI será incrementado quando você usar STOSB para colocar um pixel em ES:DI. Setando o bit para UM decrementará o endereço de memória após cada chamada.
- IF – Interrupt Enable Flag / Flag de Habilitação de InterrupçõesQuando este bit está setado, o processador responderá ainterrupções externas do hardware. Quando o bit for resetado, interrupções de hardware serão ignoradas.
- TF – Trap Flag / Flag de Trap (“armadilha”)Quando este bit estiver setado, uma interrupção ocorrerá imediatamente depois que a próxima instrução executar. Isto é geralmente usado em depurações.
- SF – Sign Flag / Flag de SinalEste bit é mudado após operações aritméticas. O bit recebe o bit de mais alta ordem do resultado, e se setado para UM, indica que o resultado da operação foi negativo.
- ZF – Zero Flag / Flag de ZeroEste bit é setado quando instruções aritméticas geram um resultado zero.
- AF – Auxiliary Carry Flag / Flag de Vai-Um AuxiliarEste bit indica que um vai-um no nibble de baixa ordem de AL ocorreu na instrução aritmética.
- PF – Parity Flag / Flag de ParidadeEste bit é setado para um quando uma instrução aritmética resulta em um número par de bits “1”.
- CF – Carry Flag / Flag de Vai-UmEste bit é setado quando o resultado de uma operação aritmética é muito grande ou muito pequena para o registrador destino ou endereço de memória.
Agora, de todos esses acima, você não precisa mesmo se preocupar muito com a maioria deles. Por enquanto, só conhecer CF, PF, ZF, IF, DF e OF será suficiente. Eu não dei comentários para os primeiros já que eles são puramente técnicos, e são usados mais no modo protegido e situações complexas. Você não deveria ter que conhecê-los.
Você pode, se quiser, mover uma cópia dos flags para AH com LAHF – (Carrega AH com Flags) – e modificar ou ler bits individualmente, ou mudar o status dos bits mais facilmente com CLx e STx. Contudo se você planeja mudar os flags, lembre-se de que eles podem ser extremamente úteis em muitas situações.
(Eles podem também ser muito enjoados quando tarde da noite, linhas começam a desenhar para trás, e você gasta um hora procurando o porquê – e então se lembra que você se esqueceu de limpar o flag de direção!)
Acho que cobrimos muito pouca coisa importante neste tutorial. Dê uma olhada nos flags, e volte naquela rotina compridona de fazer linhas, já que ela é um ótimo exemplo de controle de fluxo. Assegure-se de que suas capacidades de controlar fluxos de intruções estão perfeitas.
Semana que vem, vou tentar amarrar todos os tópicos que vimos estas poucas semanas juntos, e apresentar alguma forma de revisão de tudo que você aprendeu. Semana que vem eu também vou entrar em otimização, e como você pode acelerar todo o código com que temos trabalhado até agora.
No próximo tutorial vamos ver:
- Uma revisão de tudo que você aprendeu
- Otimização
- Declarando procedures (procedimentos) em Assembler
- Ligando seu código a C/C++ ou Pascal
Se você deseja ver um tópico discutido num tutorial no futuro, escreva-me, e eu vou ver o que eu posso fazer.
Não perca!!! Baixe o tutorial da próxima semana na minha homepage:
Vejo vocês na próxima semana!
– Adam.
– Renato Nunes Bastos