Postado por Fernando Schimit - Fox Creative

Esse tutorial foi postado em meu blog:
berseck.wordpress.com

Bom galera, eu vo aqui mostrar como que se faz um slideshow dinâmico.

Aqui como deve ficar no final



Eu criei esse slideshow devido a necessidade que eu tive...

E então fiz ele ficar dinâmico para poder adicionar quantas imagens você quiser

Então vamos ao código!

//importo as funções necessárias
import mx.transitions.Tween;
import mx.transitions.easing.*;
import flash.display.Stage;
Stage.scaleMode = "noScale";
//Crio o loader
var mcl:MovieClipLoader = new MovieClipLoader();
//Crio os clips a serem carregados
var alvo:MovieClip = _root.createEmptyMovieClip("alvo", _root.getNextHighestDepth());
var alvo2:MovieClip = _root.createEmptyMovieClip("alvo2", _root.getNextHighestDepth());
//Pego o tamanho do palco
var StageW:Number = Stage.width;
var StageH:Number = Stage.height;
//Digo a posição inicial das fotos no palco - centralizando-as
alvo._x = StageW/2;
alvo._y = StageH/2;
alvo2._x = StageW/2;
alvo2._y = StageH/2;
//Pego os valores de altura, largura, x e y dos clips
var alvoX:Number = alvo._x;
var alvoY:Number = alvo._y;
var alvoWidth:Number = alvo._width;
var alvoHeight:Number = alvo._height;
var alvo2X:Number = alvo2._x;
var alvo2Y:Number = alvo2._y;
var alvo2Width:Number = alvo2._width;
var alvo2Height:Number = alvo2._height;
//Crio minha Array
var dados:Array = new Array;
//Crio meu contador
var atual:Number = new Number;
//Função que carrega as fotos do arquivo
var carrega:LoadVars = new LoadVars();
carrega.load('slide.html');
carrega.onload = function (success:Boolean){
        if(success){
                fotos = carrega.fotos;
                var dados = fotos.split(",");
                criaarray = function(){
                        return(dados);
                }
                carregafilme(dados);
        }else{
                trace("Falha ao carregar os dados");
        }
};
//Função que carrega a primeira seqüencia de fotos
function carregafilme(dados){
        imagem1(dados, atual);
        timer = function(){
                loopeterno();
                clearInterval(tempo);
        }
        tempo = setInterval(timer, 3000);
};
// Função para avançar 1 foto
intervalo = function(){
        dados = criaarray();
        i = incrementa(dados);
        imagem2(dados, i);
        var anima1:Tween = new Tween(alvo, "_alpha", Linear.easeIn, 100, 0, 3, true);
        var anima2:Tween = new Tween(alvo2, "_alpha", Linear.easeIn, 0, 100, 3, true);
        anima2.onMotionfinished = function(){
                imagem1(dados, i);      
        }
};
// Função para voltar 1 foto
volta = function(){
        dados = criaarray();
        i = decrementa(dados);
        imagem1(dados, i);
        var anima1:Tween = new Tween(alvo, "_alpha", Linear.easeIn, 0, 100, 3, true);
        var anima2:Tween = new Tween(alvo2, "_alpha", Linear.easeIn, 100, 0, 3, true);
        anima2.onMotionfinished = function(){
                imagem2(dados, i);      
        }
};
// Função que carrega o primeiro clip
function imagem1(a, i){
        num = a[i];
        mcl.loadClip(a[i], alvo);
        mcl.addListener(this);
        return(num);
};
// Função que carrega o segundo clip
function imagem2(a, i){
        num = a[i];
        mcl.loadClip(a[i], alvo2);
        mcl.addListener(this);
        return(num);
};
// Função para aumentar 1 no numero de fotos
function incrementa(a){
        atual++
        if(atual > (a.length - 1)){
                atual = 0;
                return(atual);
        }
        return(atual);
};
// Função para diminuir 1 no numero de fotos
function decrementa(a){
        atual--;
        if(atual < 0){
                atual = (a.length - 1);
                trace(atual);
                return(atual);
        }
        return(atual);
};
//Chamo um loop eterno
loopeterno = function(){
        intervalo();
};
// Ao carregar
function onloadInit(alvo) {
        redimensionar(alvo);
        alvo._x = alvoX + (alvoWidth/2) - (alvo._width/2);
        alvo._y = alvoY + (alvoHeight/2) - (alvo._height/2);
};
// Redimensiona
function redimensionar(alvo){
        alvo._xscale = 100;
        alvo._yscale = 100;
        if(alvo._width > alvo._height and alvo._width > StageW){
                alvo._xscale = ((StageW)*(100))/alvo._width;
                alvo._yscale = alvo._xscale;
        }
        else if(alvo._height > alvo._width and alvo._height > StageH){
                alvo._yscale = ((StageH)*(100))/alvo._height;
                alvo._xscale = alvo._yscale;
        } else {
                alvo._xscale = 100;
                alvo._yscale = 100;
        }
};

mcl.addListener(this);
looptimer = setInterval(loopeterno, 9000);

Código todo comentado

Espero que vocês gostem

Qualquer coisa é só falar

Para baixar clique aqui

Abraços Postado por Fernando Schimit - Fox Creative

Postado por Fernando Schimit - Fox Creative

Nós apresentamos um costume AS3 classe SnowDisplay que pode ser usado para criar uma variedade de animações de neve. Você pode sobrepor a neve animado sobre a sua imagem ou colocá-lo atrás de um objeto. Você pode colocar seus gráficos entre duas instâncias do SnowDisplay criar incrivelmente real procurando efeitos. O tamanho da animação de neve e as propriedades da neve são controladas através de fácil manipulação de parâmetros. Damos dois exemplos abaixo. Clique em cada uma das duas imagens para abrir o applet correspondente em uma janela separada. Baixar Baixe os arquivos fonte para ambos os exemplos: snow.zip Sobre o efeito Em uma conversa recente entre nós dois aqui em Flash e Matemática (Barbara e Dan), discutimos a dificuldade de criar um efeito de queda de neve que parece realista. Observou-se que se move um pouco de neve em padrões aleatórios devido à turbulência no ar, e não para baixo, sempre em movimento. No entanto, não basta simplesmente fazer flocos de neve se mover com movimentos aleatórios independentes, porque flocos de neve perto um do outro deve mover-se de maneira semelhante. O que precisamos é de algum tipo de campo vetorial que define a aceleração causada pela turbulência, que pode ser aplicado a cada partícula de acordo com sua posição. Mas isso poderia ter computacionalmente complexa e ineficiente. Nós viemos acima com uma solução que usa o ruído Perlin para determinar a aceleração para os flocos de neve, e nós usamos um efeito de paralaxe para criar um efeito 3D. Iremos descrever este método em maior detalhe na próxima página deste tutorial. Como Personalizar Para fazer o efeito de neve tão fácil de usar quanto possível, nós criamos uma classe SnowDisplay que estende a classe Sprite. Assim, uma SnowDisplay é um objeto de exibição interativa que pode ser adicionado ao palco. Para criar um efeito de neve, basta chamar o construtor com a nova palavra-chave: neve var: SnowDisplay = SnowDisplay novo (550.300); O código acima cria uma exibição de neve de 550 de largura e altura 300. Uma vez adicionados ao palco, ele vai começar a animar flocos de neve caindo. O efeito de neve pode ser colocado sobre uma imagem da sua escolha, simplesmente por camadas de um mapa de bits (ou quaisquer outros elementos gráficos) atrás do SnowDisplay. No applet primeiro, temos que apresentou algumas das possibilidades para esta classe de neve com alguns botões que permitem que você veja alguns exemplos de definições de parâmetros diferentes. Muitos olha mais para o efeito de neve é possível, experimentar para ver o que você gosta do melhor. No segundo exemplo, temos duas instâncias de camadas SnowDisplay: um exemplo atrás de um objeto e um na frente dele. Fizemo-lo para obter o efeito de pequenos flocos de neve que aparece atrás de um objeto maior e na frente dos pinheiros. Além disso, ambos os exemplos estão por trás da janela. O código básico é adaptado de muitos exemplos de Dan partícula. A classe SnowDisplay faz uso de uma classe ParticleDisplay mais básico, que é semelhante à classe temos utilizado nos exemplos anteriores de partículas, mas simplificado. Notavelmente, fizemos uma mudança importante: os nossos exemplos anteriores feito uso de partículas que evoluiu ao longo do tempo ( recebendo maior ou menor, mudando de cor, etc.) Isto exigiu que as partículas a ser apagada e redesenhada em cada frame. Aqui as partículas não muda em nada, e tão somente as suas posições precisam ser alteradas. ParticleDisplay A classe pode ser reaproveitado para qualquer aplicação onde as partículas imutáveis são movidos em torno de uma área de exposição . Otimização de desempenho Em nossos testes, nós observamos que, com um número muito grande de flocos de neve, a animação pode ser executado com um pouco menos sem problemas em alguns computadores, especialmente sobre o Snow Leopard Macs. Para aumentar a probabilidade de uma animação suave em uma grande variedade de sistemas, os parâmetros podem ser definido o que fará com poucos flocos de neve a cair. A propriedade waitCount público da classe SnowDisplay define quantos quadros de espera antes de flocos de neve são adicionados novos para a exibição, ea propriedade pública particlesToAddEachFrame quantos conjuntos snowflakes novas serão adicionadas. Assim, uma waitCount maior ou menorparticlesToAddEachFrame causará menos flocos de neve a cair. Você pode ver vários valores para essas propriedades em ação no arquivo FLA, SnowDisplay.fla, correspondente ao nosso primeiro exemplo. Além disso, você pode experimentar com a profundidade do o efeito 3D. Usando uma maior profundidade fará com que as partículas de todo o caminho na volta a cair muito devagar, e assim permanecerá no visor durante mais tempo.Alterando os valores para o zBack e as propriedades zRange (que são explicados nos comentários dentro do código) pode configurar a animação para usar menos profundidade. Na próxima página, discutiremos as idéias por trás do efeito de queda de neve em detalhe.