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);
		}
 
	}
 
}

package  {
 
	/**
	* ...
	* @author Fellyph Cintra fellyph.com.br/blog/
	*/
 
	import flash.display.Sprite;
	import org.papervision3d.materials.utils.MaterialsList;
 
	//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;
	import org.papervision3d.objects.primitives.Cube;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.objects.primitives.Cone;
	import org.papervision3d.objects.primitives.Cylinder;
 
	// 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 MainObjetos extends Sprite {
 
		private var _viewport		:Viewport3D;
		private var _cena			:Scene3D;
		private var _camera			:Camera3D;
 
		private var _renderizador 	:BasicRenderEngine;
 
		private var esfera 			:Sphere;
		private var cubo			:Cube;
		private var cilindro		:Cylinder;
		private var plano			:Plane;
		private var cone			:Cone;
 
		private var material		:WireframeMaterial;
		private var materialPlano	:WireframeMaterial;
		private var materialList 	:MaterialsList;
 
		public function MainObjetos() {
 
			_viewport = new Viewport3D(450, 300, false, true);
			addChild(_viewport);
 
			_cena 			= new Scene3D();
			_camera 		= new Camera3D();
			_renderizador 	= new BasicRenderEngine();
 
			material = new WireframeMaterial(0xFF0000);
			materialPlano = new WireframeMaterial(0xFF0000);
 
			// a propriedade doubleSided serve para informar que o material será exibido com duas faces frente e verso
			materialPlano.doubleSided = true;
 
			materialList = new MaterialsList( { front:material,back:material,left:material,right:material,top:material,bottom:material } )
 
			//para criar as um objeto do tipo Sphere é necessário passar como parâmetro
			//( material, raio, segmentos Horizontais , número de segmentos Verticais
			esfera = new Sphere(material, 80, 7, 7);
 
			//para o objeto Cube são necessário os parâmetros , primeiro MaterialsList que diferente dos outros objetos é um Array com materiais
			//passando as faces do cubo: frente, costas(verso), lateral direita, lateral esquerda, topo  e base, ou seja,
			//você pode criar um cubo com diferentes materiais, nesse exemplo podemos ver acima, só foi utilizado apenas um material.
			//Concluindo ( materialslist, largura, profundidade, altura, segmentos horizontais, segmentos de profundidade, segmentos verticais)
			cubo = new Cube(materialList, 80, 80, 80, 2, 2, 2);
 
			// para o objeto Cylinder passamos o parametro ( material, raio , segmentos Horizontais e vertical)
			cilindro = new Cylinder(material, 30, 80, 8, 6);
 
			//para o objeto Plane ( material, largura , altura, segmentos horizontais , segmentos verticais);
			// no objeto plano estou adicionando o materialPlano porque ele tem dupla face, isso porque,
			// quando ele rotacionar a parte oposta do plano também ser exibida
			plano = new Plane(materialPlano, 60, 60 , 1 , 1);
 
			// Objeto Cone( material, raio da base, altura, segmentos horizontais , segmentos verticais);
			cone = new Cone(material, 80, 120, 8, 6);
 
			//adicionamos os objetos na Scene3D
			_cena.addChild(esfera);
			_cena.addChild(cubo);
			_cena.addChild(cilindro);
			_cena.addChild(plano);
			_cena.addChild(cone);
 
			//modificamos as posições dos objetos para não se chocarem
			cubo.x = 150;
			cilindro.x = 300;
			plano.x = - 150;
 
			cone.x = - 300; 
 
 
			//adicionamos o Evento ENTER_FRAME para fazer a renderização e movimento dos objetos
			addEventListener(Event.ENTER_FRAME, render);
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
 
		public function render(e:Event):void {
 
			esfera.rotationY += 2;
			cubo.rotationX += 2;
 
			cilindro.rotationY -= 2;
			cilindro.rotationX += 2;
 
			cone.rotationZ -= 2;
			cone.rotationY -= 2;
 
			plano.rotationY -= 2;
 
			_renderizador.renderScene(_cena, _camera, _viewport);
 
		}
 
	}
 
}

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

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

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

package classes {
 
    //Importamos as classes que vamos utilizar
	import flash.events.Event;
	import flash.display.Sprite;
	import flash.display.StageScaleMode;
 
	/**
	* ...
	* @author Fellyph Cintra http://www.fellyph.com.br/blog/
	*/
 
	// lembrando que nossa classe extends de sprite
	public class Resize extends Sprite{
 
		public function Resize() {
 
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = "TL";
			stage.addEventListener(Event.RESIZE, onResize);
 
			/*
			 * O StageScaleMode classe fornece valores para a propriedade stage.scaleMode.
			 * ela fica responsável pela escala dos objetos no palco quando o stage for redimencionado
			 * no nosso exemplo foi passado no_scale ou seja os objetos ficarão com tamanho fixo no stage
			 * a segunda propriedade é o align que recebe "TL" = TOP_LEFT resumindo o canto superior esquerdo
			 * sera  o ponto de orientação do stage.
			 * Por Fim adicionamos o Evento RESIZE , toda vez que houver um redimencionamento no stage
			 * a função onRezise vai ser chamada.
			 *
			 */
		}
 
                public function onResize(e:Event) {
			trace('Faz Alvo quando redimencionar a tela')
 
			trace("largura do stage Exibida : " + stage.stageWidth);
			trace("largura real do stage : " + stage.width );
			/*
			 * Nos Dois últimos traces é trabalhado duas propriedades do
			 * stage relacionadas a largura, a primeira traz a largura do stage exibida na tela
			 * a segunda traz o tramanho real do stage o tamanha que ele
                         * foi criado independente da exibição.
			 * Isso também é impregado para altura
			 */
			trage("altura do stage Exibida :" + stage.stageHeight );
			trace("altura real do estage : " + stage.height);
		}	
 
	}
 
}

	stage.scaleMode = StageScaleMode.NO_SCALE;
	stage.align = "TL";
	stage.addEventListener(Event.RESIZE, onResize);
 
	public function onResize(e:Event) {
		trace('Faz Alvo quando redimencionar a tela')
	}

package classes {
 
	import flash.display.Shape;
    import flash.events.Event;
	import flash.display.Sprite;
	import flash.display.StageScaleMode;
 
	/**
	* ...
	* @author Fellyph Cintra http://www.fellyph.com.br/blog/
	*/
 
	public class Resize2 extends Sprite{
 
		public var forma:Shape;
 
		public function Resize2() {
 
			// agora vamos criar um shape no palco
			forma = new Shape();
			forma.graphics.beginFill(0x990000);
			forma.graphics.drawRect(0, 0, 150, 150);
			forma.graphics.endFill();
			addChild(forma);
 
			// vamos posicionar o shape no centro do pal
			forma.x = (stage.stageWidth/2) - (forma.width/2);
			forma.y = (stage.stageHeight/2) - (forma.height/2);
 
			//fazemos o tratamento no stage
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = "TL";
			stage.addEventListener(Event.RESIZE, onResize);
 
			/*
			 * usamos o mesmo código para posicionar no centro
			 * dentro do método onResize, agora toda vez que o stage
			 * for redimensionado o shape forma irá para o centro do stage
			 */
 
		}
 
		public function onResize(e:Event) {
			forma.x = (stage.stageWidth/2) - (forma.width/2);
			forma.y = (stage.stageHeight/2) - (forma.height/2);
		}
	}
 
}

package classes {
 
	import flash.display.Shape;
    import flash.events.Event;
	import flash.display.Sprite;
	import flash.display.StageScaleMode;
 
	/**
	* ...
	* @author Fellyph Cintra http://www.fellyph.com.br/blog/
	*/
 
	public class Resize3 extends Sprite{
 
		public var forma:Shape;
 
		public function Resize3() {
 
			// agora vamos criar um shape no palco
			// com uma diferença o shape tem a mesma lagura do palco
			forma = new Shape();
			forma.graphics.beginFill(0x990000);
			forma.graphics.drawRect(0, 0,stage.stageWidth, 50);
			forma.graphics.endFill();
			addChild(forma);
 
			// vamos posicionar o shape no limite inferior do palco
			// ele vai funcionar como uma especie de rodapé
 
			forma.x = 0;
			forma.y = stage.stageHeight - forma.height;
 
			//fazemos o tratamento no stage
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = "TL";
			stage.addEventListener(Event.RESIZE, onResize);
 
			/*
			 *
			 */
 
		}
 
		public function onResize(e:Event) {
			//repetimos o posicionamento com um diferença mudamos também a largura do shape
			forma.x = 0;
			forma.y = stage.stageHeight - forma.height;
			forma.width = stage.stageWidth;
 
		}
	}
 
}

package classes {
 
	import flash.display.Shape;
    import flash.events.Event;
	import flash.display.Sprite;
	import flash.display.StageScaleMode;
 
	/**
	* ...
	* @author Fellyph Cintra http://www.fellyph.com.br/blog/
	*/
 
	public class Resize4 extends Sprite{
 
		public var forma1:Shape;
		public var forma2:Shape;
		public var forma3:Shape;
		public var forma4:Shape;
 
		public function Resize4() {
 
			//criamos 4 formas
			forma1 = new Shape();
			forma1.graphics.beginFill(0xCC0000);
			forma1.graphics.drawRect(0, 0,150, 50);
			forma1.graphics.endFill();
			addChild(forma1);
 
			forma2 = new Shape();
			forma2.graphics.beginFill(0xFFCC00);
			forma2.graphics.drawRect(0, 0,50, 150);
			forma2.graphics.endFill();
			addChild(forma2);
 
			forma3 = new Shape();
			forma3.graphics.beginFill(0x009900);
			forma3.graphics.drawRect(0, 0,150, 50);
			forma3.graphics.endFill();
			addChild(forma3);
 
			forma4 = new Shape();
			forma4.graphics.beginFill(0x000099);
			forma4.graphics.drawRect(0, 0,50, 150);
			forma4.graphics.endFill();
			addChild(forma4);
 
			// fazemos seu posicionamento
			forma1.y = 0;
			forma1.x = (stage.stageWidth/2 ) - (forma1.width/2);
 
			forma2.y = (stage.stageHeight/2) - (forma2.height/2)
			forma2.x = stage.stageWidth - forma2.width;
 
			forma3.y = stage.stageHeight - forma3.height;
			forma3.x = (stage.stageWidth/2 ) - (forma3.width/2)
 
			forma4.y = (stage.stageHeight/2) - (forma4.height/2)
			forma4.x = 0;
 
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = "TL";
			stage.addEventListener(Event.RESIZE, onResize);
 
			/*
			 * notem que o resize pode ser aplicado a mais de um objeto no palco
			 */
 
		}
 
		public function onResize(e:Event) {
			forma1.y = 0;
			forma1.x = (stage.stageWidth/2 ) - (forma1.width/2);
 
			forma2.y = (stage.stageHeight/2) - (forma2.height/2)
			forma2.x = stage.stageWidth - forma2.width;
 
			forma3.y = stage.stageHeight - forma3.height;
			forma3.x = (stage.stageWidth/2 ) - (forma3.width/2)
 
			forma4.y = (stage.stageHeight/2) - (forma4.height/2)
			forma4.x = 0;
		}
	}
 
}