b'\n_START_ARTICLE_\nZ-buffer\n_START_PARAGRAPH_\nZ-buffer \xc3\xa9 uma parte da computa\xc3\xa7\xc3\xa3o gr\xc3\xa1fica, que consiste na mem\xc3\xb3ria de um adaptador de v\xc3\xaddeo encarregada de gerir as coordenadas de profundidade das imagens nos gr\xc3\xa1ficos em tr\xc3\xaas dimens\xc3\xb5es (3-D), por forma a eliminar sobreposi\xc3\xa7\xc3\xb5es, normalmente calculados por hardware e algumas vezes por software._NEWLINE_Para que se possa realizar a representa\xc3\xa7\xc3\xa3o precisa e realista de um modelo tridimensional complexo, numa cena contendo v\xc3\xa1rios objectos diferentes, \xc3\xa9 necess\xc3\xa1rio que aquelas superf\xc3\xadcies normalmente invis\xc3\xadveis de um determinado \xc3\xa2ngulo ou ponto no mundo sejam tamb\xc3\xa9m renderizadas invis\xc3\xadveis no computador. Este problema \xc3\xa9 normalmente chamado de problema de superf\xc3\xadcie vis\xc3\xadvel (visible-surface problem), quando o objetivo \xc3\xa9 determinar quais superf\xc3\xadcies de um objecto s\xc3\xa3o vis\xc3\xadveis de um determinado \xc3\xa2ngulo, ou problema de superf\xc3\xadcie oculta (hidden-surface problem), quando o objectivo \xc3\xa9 determinar quais superf\xc3\xadcies est\xc3\xa3o invis\xc3\xadveis neste momento._NEWLINE_Foi um problema fundamental abordado pela pesquisa em Computa\xc3\xa7\xc3\xa3o Gr\xc3\xa1fica durante muito tempo. Para ilustrar o que s\xc3\xa3o os efeitos desejados de um m\xc3\xa9todo dessa fam\xc3\xadlia de algoritmos, basta observar os dois desenhos abaixo mostrando a mesma estrutura, uma em modelo de arame e outra em modelo de s\xc3\xb3lidos/superf\xc3\xadcies. A figura da direita fornece de imediato muito mais informa\xc3\xa7\xc3\xa3o sobre as posi\xc3\xa7\xc3\xb5es relativas dos objectos na cena do que o modelo de arame da esquerda._NEWLINE_De todos os algoritmos para determina\xc3\xa7\xc3\xa3o de superf\xc3\xadcie vis\xc3\xadvel, o buffer de profundidade ou Z-buffer \xc3\xa9 talvez o m\xc3\xa9todo mais simples e com certeza o mais amplamente utilizado.\n_START_SECTION_\nO Princ\xc3\xadpio de Funcionamento\n_START_PARAGRAPH_\nO princ\xc3\xadpio de funcionamento do algoritmo \xc3\xa9 muito simples: Para todos os pix\xc3\xa9is na Viewport, mant\xc3\xaam-se um registo da profundidade (em termos de coordenada z) do objecto na cena em que estiver mais pr\xc3\xb3ximo, para al\xc3\xa9m de um registo da intensidade, cor, etc, que deveria ser utilizada ao mostrar esse ponto em particular na tela do computador. Todas as vezes que um novo pol\xc3\xadgono \xc3\xa9 processado, um valor de z e de intensidade s\xc3\xa3o calculados para cada pixel que estiver dentro dos limites do pol\xc3\xadgono. Se o valor de coordenada z obtido para aquele pol\xc3\xadgono for inferior ao valor de z armazenado para aquele pixel no buffer, ent\xc3\xa3o esse objecto est\xc3\xa1 mais pr\xc3\xb3ximo do que algum objecto anteriormente renderizado naquela posi\xc3\xa7\xc3\xa3o e vai ocultar aquele objecto. Neste caso, substitui-se o valor armazenado naquela posi\xc3\xa7\xc3\xa3o do buffer por este novo valor._NEWLINE_Se n\xc3\xa3o for realizado nenhum c\xc3\xa1lculo de radiosidade ou outra t\xc3\xa9cnica de raytracing mais avan\xc3\xa7ada, ap\xc3\xb3s o processamento de todos os pol\xc3\xadgonos da cena, o buffer de intensidade/cor resultante representar\xc3\xa1 exactamente os valores dos pix\xc3\xa9is da Viewport e pode ser visualizado sem mais nenhuma transforma\xc3\xa7\xc3\xa3o.\n_START_SECTION_\nO M\xc3\xa9todo Z-Buffer\n_START_PARAGRAPH_\nO algoritmo Z-Buffer trabalha em Coordenadas de V\xc3\xaddeo ou Viewport (espa\xc3\xa7o de dispositivo) e pode ser implementado facilmente como uma extens\xc3\xa3o/modifica\xc3\xa7\xc3\xa3o de um algoritmo de convers\xc3\xa3o por varredura. O Z-Buffer ou Buffer de Profundidade, estrutura de dados da qual o m\xc3\xa9todo tira seu nome, \xc3\xa9 uma matriz [n x n] na qual o elemento (i,j)  corresponde ao pixel (i,j). Esta matriz cont\xc3\xa9m o valor de z em Coordenadas do Mundo (espa\xc3\xa7o de imagem) do objecto correntemente vis\xc3\xadvel naquele pixel. Al\xc3\xa9m disso, existe outra matriz [n x n] cujos elementos correspondem \xc3\xa0 cor ou intensidade luminosa que \xc3\xa9 para ser atribu\xc3\xadda \xc3\xa0quele pixel.\n_START_SECTION_\nExemplo\n_START_PARAGRAPH_\nConsidera-se um exemplo bidimensional com uma viewport-linha unidimensional com resolu\xc3\xa7\xc3\xa3o de 8x1 pix\xc3\xa9is e com pol\xc3\xadgonos representados como segmentos de rectas. \xc3\x89 um exemplo extremamente simplista, pois elimina o significado do eixo y, mas os passos a serem executados s\xc3\xa3o praticamente id\xc3\xaanticos \xc3\xa0 execu\xc3\xa7\xc3\xa3o do algoritmo para tr\xc3\xaas dimens\xc3\xb5es e dessa forma ficar\xc3\xa1 mais f\xc3\xa1cil para se compreender.\n_START_SECTION_\nInicializa\xc3\xa7\xc3\xa3o do Z-Buffer\n_START_PARAGRAPH_\nO buffer de profundidade \xc3\xa9 inicializado atribuindo-se a todos os seus elementos o valor -\xe2\x88\x9e, que pode ser representado por algum valor negativo extremamente alto, j\xc3\xa1 que n\xc3\xa3o se renderiza nenhum pol\xc3\xadgono at\xc3\xa9 este momento. A matriz de cores ou intensidades luminosas (para renderiza\xc3\xa7\xc3\xb5es em preto e branco) \xc3\xa9 inicializada atribuindo-se a todos os seus pix\xc3\xa9is a cor preta. Imagine o Z-Buffer como representando o volume de espa\xc3\xa7o "atr\xc3\xa1s" do buffer, na direc\xc3\xa7\xc3\xa3o z, tal qual est\xc3\xa1 desenhado na figura abaixo.\n_START_SECTION_\nMapeamento da Profundidade dos Objectos na Cena\n_START_PARAGRAPH_\nO pr\xc3\xb3ximo passo \xc3\xa9 mapear, pixel a pixel, a profundidade de cada objecto da cena que se encontra atr\xc3\xa1s daquele pixel. Toma-se cada um dos pol\xc3\xadgonos, executa-se a convers\xc3\xa3o por varredura e, durante esta convers\xc3\xa3o, executa-se os passos seguintes:_NEWLINE_1 - Verifica\xc3\xa7\xc3\xa3o de intersec\xc3\xa7\xc3\xa3o. Para cada p\xc3\xadxel, determina-se os pol\xc3\xadgonos da cena cuja convers\xc3\xa3o de varredura resultou num elemento com as coordenadas x,y deste pixel._NEWLINE_2 - Determina\xc3\xa7\xc3\xa3o da ordem de oculta\xc3\xa7\xc3\xa3o. Para todos os pol\xc3\xadgonos da cena, determina-se para cada pixel (i,j) que intercepta o pol\xc3\xadgono, se o valor z em Coordenadas do Mundo (eixo z do desenho acima) deste pol\xc3\xadgono na posi\xc3\xa7\xc3\xa3o do pixel \xc3\xa9 maior do que o valor z armazenado no Z-Buffer. Se for maior, calcula-se a cor e outros valores associados a este pixel e insere-se na entrada (i,j) da matriz de cor e insere-se o valor z do pol\xc3\xadgono naquele ponto na posi\xc3\xa7\xc3\xa3o (i,j) do z-Buffer. Sen\xc3\xa3o, n\xc3\xa3o se faz nada.\n_START_SECTION_\nExemplo de Mapeamento\n_START_PARAGRAPH_\nSe, se inserir uma linha, como mostrado em baixo, regista-se um valor de profundidade de cada pixel e obt\xc3\xaam-se os valores mostrados na figura:_NEWLINE_Se, se inserir uma segunda linha e aplicar o algoritmo acima novamente, v\xc3\xaa-se que o Z-Buffer foi actualizado e mostra o \xc3\xadndice da linha "da frente", vis\xc3\xadvel, naquele pixel e o valor de profundidade da linha naquele ponto.\n_START_SECTION_\nAlgoritmo Z-Buffer\n_START_PARAGRAPH_\nPode-se descrever na forma de um pseudoc\xc3\xb3digo bastante simples:_NEWLINE_Algoritmo Z-Buffer_NEWLINE_Dados:_NEWLINE_Lista of pol\xc3\xadgonos {P1, P2, ..., Pn}_NEWLINE_Matriz z-buffer[x,y] inicializado com \xe2\x88\x9e_NEWLINE_Matriz Intensidade[x,y]_NEWLINE_In\xc3\xadcio_NEWLINE_para cada pol\xc3\xadgono P na lista de pol\xc3\xadgonos  fa\xc3\xa7a {_NEWLINE_    para cada pixel (x,y) que intercepta P fa\xc3\xa7a {_NEWLINE_        calcule profundidade-z de P na posi\xc3\xa7\xc3\xa3o (x,y)_NEWLINE_        se prof-z < z-buffer[x,y] ent\xc3\xa3o {_NEWLINE_            Intensidade[x,y] = intensidade de P em (x,y)_NEWLINE_            z-buffer[x,y] = prof-z_NEWLINE_        }_NEWLINE_    }_NEWLINE_}_NEWLINE_Desenhe Intensidade_NEWLINE_fim_NEWLINE_Uma vez que todo pol\xc3\xadgono pode ser dividido num conjunto de trap\xc3\xa9zios (se se aceitar o tri\xc3\xa2ngulo como um trap\xc3\xa9zio degenerado de topo zero), basta-nos considerar o algoritmo Z-buffer sobre trap\xc3\xa9zios. Para tal pode-se directamente modificar o algoritmo de renderiza\xc3\xa7\xc3\xa3o, ou ent\xc3\xa3o um dos algoritmos de rasteriza\xc3\xa7\xc3\xa3o mais avan\xc3\xa7ados. Pode-se utilizar directamente os procedimentos de rasteriza\xc3\xa7\xc3\xa3o e de actualiza\xc3\xa7\xc3\xa3o de v\xc3\xaddeo implementados pelo algoritmo de convers\xc3\xa3o que for ser utilizado.'