http://www.guj.com.br/posts/list/13.java JForum - http://www.jforum.net

Eu queria saber como fazer para que o meu fundo de tela pare de piscar!!!
o meu professor sugeriu que eu usasse o paintcomponents, mais nao consegui...que q vcs me mostrem como usa-lo.

Ficarei grata se alguem puder me ajudar!!]]> http://www.guj.com.br/posts/preList/57956/304702.java http://www.guj.com.br/posts/preList/57956/304702.java GMT http://www.guj.com.br/posts/list/57701.java
E nem sequer ter criado esse segundo post:
http://www.guj.com.br/posts/list/57585.java

E nem esse terceiro, que estou respondendo agora...

Bem, tenho uma série de sugestões a fazer... Na verdade, tem bastante coisa para melhorar no seu algoritmo. Se você quer partir diretamente para a solução do seu problema, leia o meu próximo post. Mas tire um tempo para ler esse, depois.

1. O método pintar() deve ser chamado antes do método contaTempo(). Caso contrario, a tela pode piscar no primeiro quadro (você terá contado o tempo, antes de exibir qualquer imagem);

2.Existe uma regra no swing de que o objeto graphics não deve ser alterado. Para corrigir isso, sempre que utilizar um método do swing (paint, paintComponent, paintComponents, paintChildren ou paintBorder), faça o seguinte:

[code]public void paint(Graphics g)
{
Graphics tela = g.create();
//Aqui vai o seu código normal
tela.dispose();
}[/code]

No geral, essa é uma boa prática. Você garante que um método de pintura não irá interferir no outro.

3. O segredo para uma boa aplicação de animações está naquele loop, que você chamou de inicioAnimacao.

Quem deve controlar o seu próprio x, y e z são as classes que serão pintadas na tela, ou classes específicas para objetos da animação.

Geralmente, vão ser criadas classes com dois métodos, que serão chamados por seu animation loop:

processLogics(); (Ajusta o x, y e z do objeto animado)
renderGraphics(); (Pinta o objeto)

O animation loop (ou MainLoop), fica com a árdua tarefa de manter a taxa de processamento da lógica constante (independente da velocidade do hardware), enquanto mantém ao máximo possível a atualização dos gráficos (em chamadas ao paint()). Geralmente "o máximo possível" é a taxa de atualização do monitor, ou seja, em torno de 75 quadros em um segundo: mais do que isso é desperdício de processamento.

Esse tipo de abordagem é válido tanto para uma animação estática quanto para jogos de computador. Quanto à isso, fiz [url=http://vinigodoy.wordpress.com/2007/03/31/controlando-a-velocidade-de-seu-jogo/]esse post no meu blog[/url] que explica como funciona um bom animation loop.

Existe uma ótima teoria sobre o animation loop, imagens e animação no site do livro [url=http://fivedots.coe.psu.ac.th/~ad/jg/]Killer Game Programming in Java[/url].]]> http://www.guj.com.br/posts/preList/57956/304723.java http://www.guj.com.br/posts/preList/57956/304723.java GMT
Flickering é o fato da tela "piscar". Por que isso ocorre? Isso ocorre porque a imagem é exibida enquanto é desenhada. Como parte dela está pronta e parte não está, você tem a impressão da tela estar piscando. Isso acontece muito rapidamente.

As técnicas utilizadas para eliminar isso são chamadas [i]Double Buffering[/i] e [i]Page Flipping[/i]. Como isso funciona? Basicamente você trabalhará com duas imagens, uma que está em memória e outra que está desenhada na tela. Você faz os desenhos na imagem que não está sendo exibida e depois "troca" ela com a que está sendo exibida. O fato de ter duas imagens é o tal Double Buffering e troca-la de maneira imediata é o [i]page flipping[/i].

[img]http://java.sun.com/docs/books/tutorial/figures/extra/fullscreen/pageFlipping.gif[/img]

Como implementamos isso? O Java possui a classe BufferStrategy para te auxiliar a usar double buffering. Os componentes do swing também tem suporte direto a esse recurso. Faremos o seguinte:

1. Primeiramente, na última linha do construtor da janela, vamos indicar para ela que queremos [i]double buffering[/i]. Na última linha do seu construtor faça:
[code]public Janela() {
//Código de inicialização
createBufferStrategy(2); //Queremos double buffering
}[/code]

2. Depois, vamos alterar o método paint. Primeiramente, não usaremos o método paint do java diretamente. Deixemos que ele gerencie a pintura para nós. Altere o nome do método paint para pintar. Pintar não precisa receber nenhum parâmetro (nem mesmo o objeto graphics).

Na primeira linha do método pintar, pedimos a nossa BufferStrategy para retornar o objeto graphics da imagem em memória. Na última, pedimos para que esse objeto seja exibido:
[code]private void pintar() {
//Pedimos a imagem em memória
Graphics tela = getBufferStrategy().getDrawGraphics().create();
//Aqui vai o código que estava no seu paint original
tela.dispose(); //Liberamos a memória do objeto Graphics
getBufferStrategy().show(); //Fazemos o page flipping, exibindo a tela recém desenhada.
}[/code]

Agora, só falta corrigir o método inicioAnimacao() para chamar pintar() ao invés de repaint().

Pronto! O flickering foi embora!]]> http://www.guj.com.br/posts/preList/57956/304745.java http://www.guj.com.br/posts/preList/57956/304745.java GMT