Feeds:
Posts
Comentários

Posts Tagged ‘game’

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 »

Agora vamos continuar com o tutorial.

Vamos criar nosso primeiro arquivo “as”, abra o flash , inicie um novo arquivo actionscript 3.0.

Abra o flash e crie um arquivo FLA.

No canto direito na aba propridade, existe um espaço para lincar a class, só assim o flash vai chamar nossa classe.

Escreva nesse espaço Class o nome do arquivo “AS” que queremos linkar(No nosso caso vai ser Basiclass).

Salve esse FLA com qualquer nome, crie um novo arquivo agora em actionscript 3.0 com o nome Basiclass,

salve na mesma pasta do arquivo FLA.

Pronto vamos comesar.

vamos explicar o codigo “passo a passo” ok para entender a ferramentas do Papervision3D.

Insira o seguinte cabeçalho:

package {
import flash.events.Event;//para acionar um evento durante o corre o fame

import flash.display.Sprite;// Serve para stender essa classe
import org.papervision3d.view.Viewport3D;// Aqui importamos a class do viewport para abrir a janela para cena
import org.papervision3d.scenes.Scene3D;//impota uma cena
import org.papervision3d.cameras.Camera3D;/*Se botarmos um “*” depois de cameras. iremos acionar todas as cameras
mas agora as cameras são todas numa unica classe, segundo a ultima revisão do papervision */
import org.papervision3d.render.BasicRenderEnginer;//É preciso um render para a cena
import org.papervision3d.objects.DisplayObject3D;//Aqui carrega totas as partes de geometria, materias , posição do //nosso material

import org.papervision3d.materials.BitmapFileMaterial;//vamos carregar uma foto no plano

import org.papervision3d.objects.parsers.DAE;//Um converssor para importar arquivos Collada.

import org.papervision3d.objects.primitives.Plane; // vamos carregar um Plano

[SWF(width=”480″, height=”300″, backgroundColor=”#000000″, frameRate=”30″)]

public class Basiclass extends Sprite{ //Aqui extamos estamos herdando todas as funções da class Sprite
//agora iremos publicar as variaveis, iremos declarar todas como publicas para podermos manipular depois //externamente
public var camera:Camera3D;
//a camera, que é como nossos olhos

public var janela:Viewport3D;
//A viewport é a janela

public var cena:Scene3D;
//criando um cenário

public var renderEngine:BasicRenderEngine;
//importando o renderizador

public var modelo3D:DAE;
//aqui estamos preparando para receber um arquivo externo moelado no Blender3D

public var piso3D:Plane;
//preparamos para carregar o Plano

public var foto:BitmapFileMaterial;

public function Basiclass():void//Esse é o modo construto, nessa função iremos criar e adicionar a cena
//todos elementos 3D
{
camera = new Camera3D();
//aqui podemos instanciar as propiedaes da camera, tais como foco etc…

janela = new Viewport3D(400, 400, true, true);
addChild(janela);//adicionamas a janela a cena

cena = new Scene3D(); //criamos uma cena

foto = new BitmapFileMaterial(“Valentine__s_Day_by_Laumann.jpg”);//carega a textura

foto.doubleSided=true;//ela apararece dos dois lados

modelo3D = new DAE();//chamamos o modelos 3d feito no Belnder
modelo3D.load(“modelo.dae”);//aqui carregamos o moder dizendo o caminho do arquivo
cena.addChild(modelo3D);

piso3D = new Plane(foto, 2, 2, 3);//aqui podemos instanciar o Plano
cena.addChild(piso3D);

renderEngine = new BasicRenderEngine();

addEventListener(Event.ENTER_FRAME, rendere);//nessa linha se acinona o render, que nesse caso
//tem a função ENTER_FRAME, para ser rederizado sempre que ouver um evento
//toda vez que acantecer algo ele desenha tudo, é isso que o render faz

}

public function rendere(e:Event):void// nessa função iniciamos o render que é acionado pelo ENTER_FRAME

{
renderEngine.renderScene(cena, camera, janela);
//aqui rederizamos acena
modelo3D.scale = 170;
modelo3D.rotationX = 100;
modelo3D.rotationZ = 180;
modelo3D.z = -150;
camera.lookAt(piso3D);

piso3D.rotationY ++;

piso3D.scale =800;
}
}
}

Se você fez tudo certinho vai aparecer dese jeito:



Read Full Post »