Feeds:
Posts
Comentários

Posts Tagged ‘web’

Bom Continuando!!

Vamos usar o mesmo arquivo “AS”.(só copie o codigo do arquivo anterior e cole num “AS” novo)

Agora iremos não só criar um elemento 3D como também carregar com uma textura sua textura.

Bom vamos comesar.

Abra o flash, inicie um novo arquivo FLA que é a primeira opeção.

Bom no flash Cs3 a aba propriedade é em baixo, no Cs4 é na direita,

procure o campo class, vai ter um prompt(espaço para escrever algo).
Escreva o nome da class (sem o “.as”).
Que será Cubo3D.
Salve o arquivo.

Até ai tudo bem.

Agora vamos iniciar um novoa arquivo “As”.

Abra em File
New ou aperte CRTL+N

Escreva o codigo a baixo, ele esta todo comentado.
Onde temos duas “/” o flash indentifica como comentário.

package{

import flash.display.Sprite;
//Importando a classe Sprite, para poder usar
//as suas propriedades

import flash.events.Event;
//importando a class Event do flash

import org.papervision3d.cameras.Camera3D;
//class camera

import org.papervision3d.view.Viewport3D;
//importando a class Viewport3D

import org.papervision3d.scenes.Scene3D;
//importando a class Scene3D

import org.papervision3d.render.BasicRenderEngine;
//importando a class BasicRenderEgine

import org.papervision3d.objects.primitives.Cube;
//importando a class Cubo

import org.papervision3d.objects.DisplayObject3D;
//importando a class DisplayObject3D

import org.papervision3d.materials.ColorMaterial;
//importando a class ColorMaterial para usar a cor como Textura

import org.papervision3d.materials.utils.MaterialsList;
//importando a class MaterialsList para criar um array com as cores

import org.papervision3d.materials.BitmapAssetMaterial;

import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.materials.MovieAssetMaterial;
//import org.papervision3d.materials.WireframeMaterial;

import com.greensock.*;
import com.greensock.easing.*;
//classe do TweenMax um conjunto de class
//em que torna as animações do flash muito mais leves e rapidas

public class Cubo3D extends Sprite{
//Extendendo a class Cubo3D a class Sprite, tornando a class
//Cubo3D uma sub class da Sprite

public var camera:Camera3D;
//Carregamos as propriedades da class Camera3D
//na variavel camera

public var viewport:Viewport3D;
//Carregamos as propriedades da class Viewport3D
//na variavel viewport

public var scene:Scene3D;
//Carregamos as propriedades da class Scene3D
//na variavel scene

public var render:BasicRenderEngine;
//Carregamos as propriedades da class BasicRenderEngine
//na variavel render

public var cubo3d:Cube;
//Carregamos as propriedades da class Cube
//na variavel cubo3d

public var amarelo: ColorMaterial;
//Aqui adicinaremos o material ColorMatirial
//a cada variavel com o nome da sua respectiva cor

public var laranja: ColorMaterial;
//depois de amarelo
//a laranja

public var vermelho: ColorMaterial;
//avermelha

public var preto: ColorMaterial;
//a preta

public var azul: ColorMaterial;
//a azul

public var verde: ColorMaterial;
//a verde

public var materialBiblioteca:BitmapAssetMaterial;
//Carregamos as propriedades da class BitmapAssetMaterial
//na variavel materialBiblioteca

public var mc:DisplayObject3D;
//Carregamos as propriedades da class DisplayObjeto3D
//na variavel mc

public var plano:Plane;
//Carregamos as propriedades da class Plne
//na variavel plano

public var planoMovie:MovieAssetMaterial;
//Carregamos as propriedades da class MovieAssetMaterial
//na variavel planoMovie

public var papelobj:Plane;
//Carregamos as propriedades da class Camera3D
//na variavel camera

public function Cubo3D ():void {
//Essa é a class construtora, onde contruiremos
//uma cena 3D

camera = new Camera3D();
//criando uma camera

viewport = new Viewport3D(800, 800, true, true);
//construindo uma viewport
addChild(viewport);
//adicionamos a viewport a cena

scene = new Scene3D();
//adicionamos uma cena

render = new BasicRenderEngine();
//canstruindo um render

amarelo = new ColorMaterial(0xFFFF00, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

laranja = new ColorMaterial(0xF7AE09, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

vermelho = new ColorMaterial(0xEE1111, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

preto = new ColorMaterial(0x000000, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

azul = new ColorMaterial(0x0480FB, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

verde = new ColorMaterial(0x81C639, 0.5, true);
//aqui instanciamos as propriedades das ColorMaterial
//como a cor, o alpha que vai de 0 a 1,toas as cores estão com alpha
//em 50% e estão com a função interativa como verdadeira(true)

materialBiblioteca = new BitmapAssetMaterial(“kirby”);
//carrego aqui um bitmap
//direto da biblioteca do flash

materialBiblioteca.doubleSided = true;
//Estou usando a propriedade doubleSided
//e instanciando ela como verdadeira(true)
//poderiamos usar a propriedade oneSid
//fazendo isso eu estou indicando que o material
//deve aparecer dos dois lados

plano = new Plane(materialBiblioteca, 400, 400, 4, 4);
//Estou aqui instanciando o objeto Plane
//carreguei ele com o material da biblioteca do flash
scene.addChild(plano);
//adiciono o plano a cena

mc = new DisplayObject3D();
//esse é um pivo que tem a caracteristica de ser envisivel
//onde o cubo cerá filiado a ele
scene.addChild(mc);
//adiciono ele a cena

planoMovie = new MovieAssetMaterial(“bolinha”, true);
//carregando um movieClip da
//biblioteca do flash dando o nome dele onde foi linkado no asset
//liguei o alpha como verdadeiro(true)

papelobj = new Plane(planoMovie, 700, 700, 7, 7);
//Estou aqui instanciando o objeto Plane
//carreguei ele com o material do tipo MovieClip da biblioteca do flash

//material.oneSide = false faz o mesmo que doubleSided = true;
//material.opposite = true; inverte a visualização da meteria

scene.addChild(papelobj);
//adicionado mais um plano acena

var color : MaterialsList = new MaterialsList();
color.addMaterial(amarelo, “front”);
//adiciono a variavle com a cor e a face do cubo corespondente
color.addMaterial(laranja, “back”);
color.addMaterial(vermelho, “left”);
color.addMaterial(preto, “right”);
color.addMaterial(azul, “top”);
color.addMaterial(verde, “bottom”);
//contruindo um array com todas as cores
//onde será nescerário para adicionar ao cubo

cubo3d = new Cube(color, 300, 300, 300);
//construindo o cubo, instanciando ele com a materia ColorMaterial
//que está carregado com a variavel color
//depois intanciamos a largura, depois altura e profundidade

mc.addChild(cubo3d);
//adicionamos o cubo a cena
//usamos o metodo de filiação para animar o cubo
//filiamos o cubo ao pivot(mc)
//o pivot(mc) será o pai e o cubo será o filho

addEventListener(Event.ENTER_FRAME, _enter);
//criamos um addEventeListener com a função ENTER_FRAME
//que irar fazer com que o render desenhe toda cena a cada evento
//a cada evento o ENTER_FRAME vai chamar a função _enter

}

public function _enter(e:Event):void{
//essa é a função que faz o render iniciar

render.renderScene(scene, camera, viewport);
//aqui diz onde o ENTER_FRAME vai detectar os eventos
//para o render

TweenLite.to(papelobj, 4, {x:400, rotationY:-100, ease:Back.easeOut});
//usei a classe TweenMax para deslocar e rotacionar o plano

//trace(plano.boundingBox().size); //cria uma caixa dizendo o tamanho do objeto 3d
plano.yaw(-8);
//fiz uma animação com o plano girando no eixo Y

cubo3d.x = -450;
//desloquei o cubo para esquerda

//cubo3d.rotationX +=5;
camera.lookAt(mc);
//indiquei a camra para olhar para o pivot(mc)

mc.rotationY +=5;
//estou rotacionando o pivot(mc)
//como o cubo está filiado ao pivot(mc)
//ocubo irá girar

//plano.scaleX =1; faz alteração na escala do eixo X

cubo3d.rotationX += 5;
//rotaciono o cubo no eixo X
//cubo3d.rotationY +=3;
}

}

}

se estiver certo o resutado será esse:

Cubo3D

Read Full Post »