Olá pessoal com o intuito de desenvolver a comunidade de desenvolvedores AS3Devs, iniciará o grupo de estudo sobre ActionScript 3.0 Aprender os conceitos básicos sobre a linguagem. Os encontros serão presenciais(mensal) e online(semanal). É um grupo aberto sem restrição sobre formação, o requisito básico é a vontade de aprender.

Encontros onlines serão todas as quartas-feiras, e os encontros presenciais serão realizados mensalmente.

O primeiro encontro presencial será realizado em 3 cidades: São Paulo, Rio de Janeiro, Salvador e Espirito Santo nas respectivas escolas DRC , INFNET , BR MULTIMIDIA e SIMBIONTE no dia 18 de março de 2011 as 20h.

Inscrições inicialmente não estava utilizando nenhum cadastro simplesmente chegar e levar seu notebook. Para ficar por dentro das palestras futuras só seguir o perfil do @asdevs no twitter ou acompanhar o blog www.as3dev.com.br. Você também pode se registrar em http://asdevs.groups.adobe.com/ e receba um aviso por e-mail antes de todas as reuniões.

Dinâmica das reuniões
- Cada reunião terá um tema previamente definido e um dos participantes do grupo será responsável por passar o conteúdo.
- Em cada reunião, haverá um “monitor” que acompanhará a explicação para ter certeza de que o conteúdo está sendo passado corretamente.
- A definição do próximo tema e do participante que explicará o assunto será sempre definida ao final da reunião.

O melhor de tudo, além de aprender mais sobre actionScript, aumentar o seu network, você ainda concorre a brindes, agora claro não é chegar e ganhar os ganhadores serão definidos pelo o número e nível de participação no grupo. Os brindes vão desde canetas a licenças de software da Adobe.

Primeira aula dia 18/03 às 20h: Introdução ao Actionscript com Fábio Flatchart

Sobre : Fábio Flatschart

Consultor das áreas de Internet e Computação Gráfica da Gerência de Desenvolvimento (GD2) do SENAC-SP na produção de eventos, novas parcerias e desenvolvimento de cursos livres, de nível médio, superior e de pós-graduação. Consultor Educacional da Adobe Systems do Brasil.

blog : http://quadrodosbemois.com.br/
twitter : @fabioflat

Essa aula será presencial no Rio de Janeiro (Instituto Infnet), São Paulo (DRC), Salvador (BR Multimídia) e também online.

Online: http://experts.adobeconnect.com/ge1_introducao_ao_actionscript/

DRC – São Paulo
drc.com.br
Rua Joaquim Floriano, 733, 8.º Andar Itaim Bibi

View Larger Map

Infnet – Rio de Janeiro
infnet.com.br
Rua São José, 90 – Centro do Rio
2 piso, Rio de Janeiro – RJ, 20010-020

View Larger Map

BR Multimídia – Salvador
brmultimidia.com.br
Centro Empresarial Iguatemi: Av Tancredo Neves 274, Bloco B, Sala 308 – Cam. das Árvores

View Larger Map

Simbionte – Espírito Santo
Rua 15 de Novembro, 678 – Praia da Costa

Reuniões presenciais em outros estados/cidades
Quem desejar manter uma reunião presencial das reuniões do Grupo de Estudos do ASDevs, entre em contato com filipe.cunha@gmail.com com o assunto “Reuniões Presenciais Grupo de Estudos“

Antes com velho as2 para habilitar o full screen você utilizava o comando fscommand. No AS3 a história mudou, para trabalhar com full screen você tem que acessar o stage e modificar a propriedade “displayState” ela específica o estado de exibição a ser usado. Essa propriedade trabalha com a classe StateDisplayState.

A classe StageDisplayState é simplesmente responsável por definir os valores válidos pela propriedade “displayState”. StateDisplay guarda dois valores

StageDisplayState.FULL_SCREEN : Define o modo de exibição tela cheia full screen

StageDisplayState.NORMAL : Define o modo de exibição padrão do Flash

Lembrado que qualquer entrada de teclado é desabilitada quando o Stage está no modo fullScreen.

O código para habilitar o modo fullScreen em as3 é da seguinte forma :

import flash.display.StageDisplayState;
 
// em meu arquivo Flash eu adicionei um movieClip com o nome de instância "cliqueTela"
 
 
// adicionando um listener para quando clicar no botão verificar 
cliqueTela.addEventListener(MouseEvent.CLICK, onClick)
 
cliqueTela.buttonMode = true;
cliqueTela.alpha = 0.5; 
 
//função para verificar se o stage está em fullScreen se estiver 
function goFullScreen():void{
	//verifica e que estado o Flash está "se estiver no estado normal habilita o modo fullScreen"
	if (stage.displayState == StageDisplayState.NORMAL) {
		cliqueTela.alpha = 1;
        stage.displayState = StageDisplayState.FULL_SCREEN;
    } else {
		cliqueTela.alpha = 0.5
        stage.displayState = StageDisplayState.NORMAL;
    }
}
 
 
function onClick(event:MouseEvent):void
{
    goFullScreen();
}

Para o modo full screen funcionar é preciso fazer uma alteração em nosso arquivo HTML habilitar a exibição full screen do contém Flash. Por exemplo mostrar um trecho do código HTML:

...
<div id="flashContent">
			<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" width="550" height="400" id="fullscreen" align="middle">
				<param name="movie" value="fullscreen.swf" />
				<param name="quality" value="high" />
				<param name="bgcolor" value="#ffffff" />
 
				<param name="allowfullscreen" value="true" />
                                ...

Se estiver utilizando swfobject o código fica assim :

<script type="text/javascript">
 
var flashvars = false;
var params = { };
 
swfobject.embedSWF("myContent.swf", "myContent", "300", "120", "9.0.0","expressInstall.swf", flashvars, params);
 
</script>

A Classe TextField tem 4 eventos: change, link, scroll e input. Nesse tutorial vou trabalhar com o evento “change” para fazer um pequeno contador de caracteres. O evento change como o nome sugere é chamado quando o inputText é alterado. Então vamos começar o tutorial:

package
{
	//importando as classes necessárias
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.text.TextField;
	import flash.text.TextFieldType;
 
	/**
	 * ...
	 * @author Fellyph Cintra
	 */
	public class ContaTexto extends MovieClip
	{
		//
		public var campoInput	:TextField;
		public var campoConta	:TextField;
		public var titulo		:TextField;
 
		public var contador		:Number = 0;
		public var maximo		:Number = 140;
 
		public function ContaTexto()
		{
			// instanciando os campos
			campoConta 	= new TextField();
			campoInput 	= new TextField();
			titulo 		= new TextField();
 
			//definindo nosso campo input
			campoInput.type = TextFieldType.INPUT;
 
			//definindo a quantidade maxima de caracteres que é 140
			campoInput.maxChars = maximo;
 
			//adicionando os campos ao palco
			addChild(campoInput);
			addChild(campoConta);
			addChild(titulo);
 
			titulo.text = "digite seu texto";
			titulo.x = 50
			titulo.y = 30
 
			//definindo algumas caracteristicas do textIpunt
			campoInput.width		= 200;
			campoInput.height 		= 80;
			campoInput.border		= true;
 
			// definir como multline
			campoInput.multiline	= true;
 
			// definir a quebra de linha quando chegar no final
			campoInput.wordWrap		= true;
			campoInput.x 			= 50;
			campoInput.y 			= 50;
 
			campoConta.width 		= 50;
			campoConta.height 		= 20;
			campoConta.border		= true;
			campoConta.y 			= 135;
			campoConta.x 			= 200;
 
			campoConta.text 		= "140";
 
			//adicionando o evento change ao campo de texto
			//notem que change não um TextEvent e sim um Event
			campoInput.addEventListener(Event.CHANGE, onChange);
		}
 
		private function onChange(e:Event):void
		{
			// subitraindo o numero maximo pela quantidade de caracteres
			campoConta.text = maximo - campoInput.text.length  + "";
		}
 
	}
 
}

O código já está comentado para facilitar o entendimento, mas o princípio básico é:

• Definir a quantidade máxima de caracteres
• Adicionar o evento de listener
• E fazer o tratamento na função que o listener chama

o resultado vai ser o seguinte:

A i2 Tecnologia abriu uma vaga para programador Java e AS3, para criação de jogos e aplicativos para celular em AS3 e criação se server em Java.

Gostar de jogos e já ter feito alguma programação para jogos em AS3 são pre-requisitos. É para contratação CLT.

Interessados, favor enviar currículo para:

http://www.i2tecnologia.com.br/v2/?pag=jobs

O FlashDevelop ferramenta para desenvolvimento de projetos em AS3 e AS2 opensource, lançou uma nova versão hoje 27 de agosto, com pequenas melhorias de desempenho e nos plugins já existentes. Para baixar a nova versão(3.0.3 RTM) acesse o link abaixo :

http://www.flashdevelop.org/community/viewtopic.php?f=11&t=5339

Não tive a oportunidade de ver todos, mas vi que o site tem uma variadade muito boa de tutoriais de games em flash tanto em as2 como as3. Os tutoriais são divididos em partes isso ajuda muito no aprendizado.   segue o link : http://www.flashgametuts.com/

Nesse tutorial vamos trabalhar com Tweenlite + Papervision, para trabalhar com esse esquema é bastante simples, basta importar as classe do Tweenlite e + Papervision para o nosso projeto, que ficará da seguinte forma :

Papervision a pasta : org
O link para baixar as classes do papervision clique aqui.

Tweenlite a pasta : gs
O link para baixar as classes do Tweenlite clique aqui.

Para mais detalhes sobre papervision veja os posts:

TUTORIAL PAPERVISION 3D 2.0

PAPERVISON 3D – OBJECTS PRIMITIVE

PAPERVISION 3D – MATERIALS(MATERIAIS)

Para mais detalhes sobre Tweenlite veja os posts:

TWEEN LITE

Para desenvolver esse tutorial vou trabalhar com flash IDE(bom e velho cs3) + flash develop, mas você pode utilizar só o flash, jogando direto no fla o código ou criando um arquivo AS3, mas para códificação eu indico o flashdevelop.
Voltando para na nossa ide vou criar três movieClips: letraM, letraA, letraR; para os três vou utilizar o mesmo nome para o linkage: letraM, letraA, letraR, como na imagem abaixo:

Vou criar uma class “Interatividade.as” e agora vamos para o código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

package  {
	import flash.display.Scene;
	import flash.display.Sprite;
 
	import flash.events.Event;
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	import org.papervision3d.materials.MovieAssetMaterial;
 
	import org.papervision3d.objects.primitives.Plane;
 
	import gs.TweenLite;
	import gs.easing.*;
 
	/**
	* ...
	* @author Fellyph Cintra
	* @link http://fellyph.com.br/blog/
	*
	*/
	public class Interatividade extends Sprite{
		// criar os objetos chave para trabalhar com papervision
		private var _viewport 		:Viewport3D;
		private var _cena 			:Scene3D;
		private var _camera 		:Camera3D;
 
		// meu renderizador
		private var _renderizador 	:BasicRenderEngine;
 
		// os planos que eu vou trabalhar
		private var _m				:Plane;
		private var _a				:Plane;
		private var _r				:Plane;
 
		//os materiais que vão compor meus planos(Plane)
		private var material_m 		:MovieAssetMaterial;
		private var material_a		:MovieAssetMaterial;
		private var material_r 		:MovieAssetMaterial;
 
		// o construtor da minha classe que executar o código
		public function Interatividade() {
 
			_viewport = new Viewport3D(450, 300, false, true);
			addChild(_viewport);
 
			// inicializando os objetos chave;
			_cena 			= new Scene3D();
			_camera 		= new Camera3D();
			_renderizador 	= new BasicRenderEngine();
 
			// inicializando meus materiais "MovieAssetMaterial" lembrando
			// MovieAsset trabalha com o linkage dos movieclips criados no
			// meu arquivo ".fla"
			material_m = new MovieAssetMaterial("letraM", true, true);
			material_a = new MovieAssetMaterial("letraA", true, true);
			material_r = new MovieAssetMaterial("letraR", true, false);
 
			//adicionando os materiais a cada respectivo Plane
			_m = new Plane(material_m, 100, 94, 8, 8);
			_a = new Plane(material_a,100, 94, 8, 8);
			_r = new Plane(material_r, 100, 94, 8, 8);
 
			//Adicionando o Plane a Cena
			_cena.addChild(_m);
			_cena.addChild(_a);
			_cena.addChild(_r);
 
			//Abaixo vou trabalhar com as propriedades dos meus planos
			//para em seguida executar a animação
			_m.x   = 10;
			_a.x   = 100;
			_r.x   = 200;
 
			_m.rotationY = 90;
			_a.rotationY = 90;
			_r.rotationY = 90;
 
			_m.rotationX = 90;
			_a.rotationX = 90;
			_r.rotationX = 90;
 
			// Adicionando o evento ENTER_FRAME para renderizar meu arquivo
			addEventListener(Event.ENTER_FRAME, onRender);
 
			// E por fim executamos as animações nos planos
			// Revisando:
			// TweenLite.to( objeto a ser animado, tempo , {propriedades da animação});
			TweenLite.to(_m, 4,  { rotationX:0, rotationY:0,  z:-500,  	ease:Expo.easeOut } );
			TweenLite.to(_a, 4,  { rotationX:0, rotationY:0, z: -400, 	ease:Expo.easeOut , delay:0.3 } );
			TweenLite.to(_r, 4,  { rotationX:0, rotationY:0, z:-300, 	ease:Expo.easeOut , delay:0.6} );
 
		}
 
		public function onRender(e:Event):void {
			//renderizando
			_renderizador.renderScene(_cena, _camera, _viewport);
		}
 
	}
 
}

Para testar nosso filme temos que atrelar nossa classe ao arquivo fla.
no meu exemplo eles estão na mesma pasta, fla e as então utilizamos como na imagem abaixo

o código acima já está comentado, a estrutura é a mesma inicializa os objetos, aplica os materiais aos Objetos primitivos, adiciona os objetos a cena e por fim renderiza o filme. O adicional é que no final do construtor utilizamos a Classe TweenLite. E o resultado que temos é o seguinte :

Lembrando a classe de Tween sem a renderização não funciona.

Esse post é bastante simples, vamos tentar complicar nos próximos posts.
Até breve…

Olá pessoal nesse post eu vou falar sobre Papervision 3D(obs. esse post está em rascunho desde o ano passado), ela é uma engine que simula um ambiente 3D dentro do flash com um conjunto de classes que através de cálculos gera um ambiente altura, largura e profundidade.Mas lembrando que a nova versão do flash já tem um suporte nativo para 3D.

Atualmente existem várias engines 3D no mercado, sendo Papervision a mais popular. Com essa engine podemos trabalhar com formas como: planos , cubos , cilindros, cones e objetos complexos, exportados por ferramentas 3D, por exemplo, Blender.

Mais informações no site do projeto no google code: http://code.google.com/p/papervision3d/

Blog oficial: http://blog.papervision3d.org/

Um exemplo no site : http://www.papervision3d.org/

Vamos começar de leve, para esse tutorial será necessário baixar a versão 2.0 do papervision, no site : http://papervision3d.googlecode.com/files/Papervision3D_2.0_beta_1_src.zip

Descompacte o zip, o aqui contém uma pasta chamada src, dentro dessa pasta tem os seguintes arquivos :

Como na imagem a cima a pasta src possui as seguintes pastas nochump e org.

Copie a pasta “org” para o local do seu projeto. (no meu caso criei uma pasta papervision e em seguida criei um projeto com o flash Develop).

Para compilar o código eu vou utilizar flash develop + flex SDK que você pode ver o tutorial como utilizar aqui, se tudo der certo o flash develop irá reconhecer as classes do paperVision, crie uma classe chama Main e vamos ao código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package  {
 
	/**
	* ...
	* @author Fellyph Cintra fellyph.com.br/blog/
	*/
 
	import flash.display.Sprite;
 
	//Classes necessárias para trabalhar com 3D
	//em termos de visualização
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	//objeto a ser utilizado
	import org.papervision3d.objects.primitives.Sphere;
 
	// o Material a ser aplicado no objeto 3d
	import org.papervision3d.materials.WireframeMaterial;
 
	public class Main extends Sprite {
		// para criar um ambiente 3D precisamos desses três elementos para
                //visualização de de nosso ambiente, resumindo :
                // Viewport é responsável pela área que irá ser exibida
                // Scene3D é responsável pelos objetos 3d aplicados na tela
                // Camara3D será nossa visão do ambiente 3d
 
		private var _viewport		:Viewport3D;
		private var _cena			:Scene3D;
		private var _camera		:Camera3D;
 
		// BasicRenderEngine cuidará da renderização de nosso ambiente.
		private var _renderizador 	:BasicRenderEngine;
 
                //Sphere é nosso objeto primitivo 3D
		private var esfera 			:Sphere;
 
                // WireframeMaterial é camada do objeto primitivo ou seja nossa Textura
                // WireframeMaterial é um dos materiais mais simples do paperVision são
                // apenas linhas que contornam os vértices do meu objeto.
		private var material		        :WireframeMaterial;
 
		public function Main() {
 
			_viewport = new Viewport3D(450, 300, false, true);
			addChild(_viewport);
 
			_cena 			= new Scene3D();
			_camera 		= new Camera3D();
			_renderizador 	= new BasicRenderEngine();
 
			material = new WireframeMaterial(0x330000);
 
			esfera = new Sphere(material, 80, 6, 6);
 
			_cena.addChild(esfera);
 
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
 
	}
 
}

Para que não esta ambientado com POO, vou fazer um resumo bem “Basicão”:

1. Na primeira linha definimos o pacote que a classe está “package {” nesse caso a classe está na raiz do projeto.
2. Importamos as classes necessárias
3. Iniciamos nossa classe ” public class Main extends Sprite { “
4. Definimos nossos atributos
5. Iniciamos nosso construtor (o construtor é o primeiro método a ser executado em uma classe) “public function Main() {“

Para esse tutorial para ficar simples eu joguei todas as operações dentro do construtor, para entender melhor vamos ver o passo-a-passo de nosso construtor:

• Primeiro criamos um novo Viewport3D, passamos como parâmetro ( largura:Number, altura:Number, autosize:Boolean e interatividade:Boolean ), existem outros parâmetros, mas não serão abordados nesse tutorial.
• Adicionamos o Viewport no palco.
• Instânciamos novos _renderizador, _cena e _camera.
• Criamos um novo material e passamos com parâmetro a cor.
• A instancimos uma nova esfera Objeto do tipo Sphere , para isso são necessário os parâmetros, o material , o raio da esfera, e a quantidade de segmentos horizontais e verticais
• Adicionamos a esfera na _cena
• por fim renderizamos nosso ambiente

Nesse esquema utilizado o nosso ambiente será renderizado apenas uma vez o resultado podemos ver abaixo:

Diferente do modelo acima o legal é dar movimento aos objetos, nesse caso precisamos  renderizar o nosso ambiente varias vezes, para isso utilizamos o Evento ENTER_FRAME, então, vamos ao código :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

package  {
 
	/**
	* ...
	* @author Fellyph Cintra fellyph.com.br/blog/
	*/
 
	import flash.display.Sprite;
 
	//Classes necessárias para trabalhar com 3D
	//em termos de visualização
 
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.cameras.Camera3D;
 
	//objeto a ser utilizado
	import org.papervision3d.objects.primitives.Sphere;
 
	// o Material a ser aplicado no objeto 3d
	import org.papervision3d.materials.WireframeMaterial;
 
	//importamos o Event para utilizar o ENTER_FRAME
	import flash.events.Event;
 
	public class Main extends Sprite {
 
		private var _viewport		:Viewport3D;
		private var _cena			:Scene3D;
		private var _camera		:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
 
		private var esfera 			:Sphere;
		private var material		:WireframeMaterial;
 
 
 
		public function Main() {
 
			_viewport = new Viewport3D(450, 300, false, true);
			addChild(_viewport);
 
			_cena 			= new Scene3D();
			_camera 		= new Camera3D();
			_renderizador 	= new BasicRenderEngine();
 
			material = new WireframeMaterial(0x330000);
 
			esfera = new Sphere(material, 80, 7, 7);
 
			_cena.addChild(esfera);
 
			//adicionamos o Evento ENTER_FRAME
			addEventListener(Event.ENTER_FRAME, render);
 
		}
 
		public function render(e:Event):void {
			esfera.rotationY += 2;
			_renderizador.renderScene(_cena, _camera, _viewport);
		}
 
	}
 
}

Vamos lá a diferença para o modelo anterior é que, aumentei o número de segmentos da esfera para ficar visualmente melhor e adicionamos um evento ENTER_FRAME que chama o método “render” que faz duas coisas simples incrementa o rotationY e renderiza nosso ambiente a cada vez que o método é chamado.

O Resultado é o seguinte :

Próximo tutorial vou falar mais um pouco sobre papervision.

Quando comecei a reescrever esse post era dia 30 de março, aniversário do meu amigo André Ponce, Parceiro sempre ajudando quando possível, terminei de escrever 2 horas do dia 31 março, foi mau ai Ponce. Parabéns atrasado.

Até breve…

A Greensock lançou a versão 10.0 do seu pacote de animação, segundo a greensock essa versão vem com mudanças significativas essas mudanças necessitaram de uma página completa sobre a nova versão : http://blog.greensock.com/new/

Entre as novidades :

Melhorias de performance :  Até 40% mais rápido sob animações pesadas. 

Plugin architecture: A maioria das propriedades especiais que TweenLite e TweenMax possuiam foram separadas, então você so utiliza quando precisar ativando as propriedades através do Plugin Architecture, melhorando o desempenho e economizando espaços em suas animações.

exemplo :

Vou criar um novo fla no flash, criar um movieclip com o nome “bola_mc” e inserir o seguinte código no primeiro frame.

1
2
3
4
5

import gs.plugins.*;
import gs.TweenLite;
 
TweenPlugin.activate([GlowFilterPlugin]);
TweenLite.to(bola_mc, 1.3, { glowFilter: { color:0xff0000, alpha:1, blurX:50, blurY:50 } });

Notem que agora é possível utilizar o glowFilter com tweenlite, na linha 1 eu importei os plugins na linha, 4 eu ativei o filtro e por fim executei a animação. Visualmente não há nenhuma diferença, em armazenamento, sim com Tweenlite e plugin a animação ficou com 6kb e com TweenMax a animação ficou com 14kb.

TweenFilterLite foi retirado: com a estrutura de plugin o TweenFilterLite foi aposentado.

frameLabel feature : nova propriedade, traz a possibilidade de animar os frames de um Movieclip até um frame com label especificado.

exemplo:

1
2
3
4

import gs.TweenLite;
import gs.easing.*;
 
TweenLite.to(bola_mc, 2, {frameLabel:"label2", ease:Bounce.easeOut});

“startAt” feature : Define os valores iniciais para o início da Tween

Eliminado allTo(), allFrom(), sequence(), e multiSequence() da TweenMax : Essas propriedades pertencem agora ao TweenGroup (classe para animações de array de objetos).

Altera a sintaxe “shortRotation” : Agora é possível simular uma rotação 3D, com o shortRotation passando as variáveis para, rotationX, rotationY e rotationZ. Fica mais fácil de entender no próximo exemplo :

1
2
3
4

 import gs.TweenMax;
import gs.easing.*;
 
TweenMax.to(quadrado_mc, 2, { shortRotation: { rotationY: -180}, ease:Bounce.easeOut} );

Criei um movieclip no meu cenário com o o nome de instância quadrado_mc, mesmo esquema seleciono o primeiro frame, e insira o código.

o resulta é o seguinte: 

mais informações no site da greensock

até a próxima …

Meio atrasado mas esse post estava perdido nos meus rascunhos, saiu dia 27 de dezembro o relase 3.0.0 RCI do flash develop para baixa clique aqui. Entre as melhorias do novo release estão : 

• swc externos agora aparecem como classpath.
• a possibilidade de explorar um swc com duplo clique.
• melhor integração com flash player 10.
• erros de sitaxe ao vivo para as3.
• atualizado o MXML completation.

O grupo do Flash Develop sempre aconselha fazer Backup dos seu projetos quando for instalar uma nova versão, eu sinceramente nunca faço isso.

Até a Próxima.