Importando um arquivo Collada (DAE)

O Papervision3D permite que você crie desde modelos simples baseados em primitivas 3-D até sólidos complexos, sejam orgânicos como um rosto ou até mesmo algo baseado em uma função matemática.

Porém, usar um plano ou uma esfera como elemento de um site é uma coisa, modelar algo orgânico ou mais complexo é outra.

Nos primórdios da computação gráfica 3-D era comum que artistas-programadores criassem seus modelos atravéz de uma sequência de coordenadas X,Y e Z. Só que isso é realmente demorado, chato e desmotivante.

Hoje em dia, temos inúmeras ferramentas que nos permitem modelar o que desejamos sem muito esforço. Como estamos falando de código livre, posso citar o Blender, como exemplo-mor.

Para aqueles que estão entrando agora no mundo da modelagem, aconselho utilizarem programas mais simples, como o Sketchup, que roda no Linux sem muito esforço. Sim, eu sei que ele é fechado e etc., mas não podemos ter medo de conhecer o lado negro da força 🙂

Felizmente, esse tutorial não cobrirá introdução a modelagem 3-D, pois já contamos com um arquivo que criado anteriormente no Blender e exportado como Collada (.dae).

Você poderá baixar o arquivo aqui:

http://www.ciceromoraes.com.br/download.php?id=34

Baixe os arquivos dentro da pasta Tutorial que criamos anteriormente e descompacte-o.

Não vou explicar novamente como você deve fazer para baixar e descompactar o arquivo. Com os exemplos anteriores já deu para se ter uma boa noção.

Vamos dar uma olhada no que tem dentro da pasta descompactada.

Temos dois diretórios:

1) 3D onde coloquei o arquivo do Blender com o exemplo que utilizaremos.

2) arquivos onde estão os arquivos Collada (.dae) e os arquivos de textura (.jpg) que usaremos na superfície do exemplo.

A título de curiosidade, se você entrar no diretório 3D e abrir o arquivo criado.blend poderá ver o criado mudo rústico que foi modelado para esse exercício.

É evidente que você precisa do Blender instalado no seu sistema para poder abrir o arquivo.

As texturas do objeto foram criadas com uma tecnologia chamada Baking. Graças a essa técnica dispensamos o uso de luzes com sombra em nossa cena.

Caso você deseje entender o que é a tecnologia e para que serve, veja o roteiro que criei anteriormente nesse mesmo site:

https://www.hardware.com.br/tutoriais/flexsdk-papervision3d-blender3d/

Agora vamos voltar ao escopo do tutorial.

Dentro do diretório arquivos tem oito arquivos. Quatro .dae e quatro .jpg.

Vamos entender direitinho o que está acontecendo.

Os arquivos .dae tem uma estrutura de .XML com todos os dados em três dimensões do objeto seu, posicionamento no espaço e dados de “recorte” para as imagens .jpg que aparecem em baixo.

A coisa funciona, como se o arquivo .dae fosse o modelo tridimensional, mas branco, sem detalhe de mapeamento e textura. As imagens .jpg seria uma espécie de papel que se recortado, colaria em todas as faces do objeto milimetricamente.

Agora vem a pergunta:

Por que existem 8 arquivos?

Bem, a coisa funciona assim. Pense em cada arquivo como uma parte do criado. Como os arquivos .dae geralmente posicionam os objetos nas coordenadas X, Y e Z cada parte está em seu devido lugar. Quando importamos todos eles no nosso projeto, cada um respeitará o seu espaço e essa composição culminará no criado mudo rústico.

Aqui a coisa começa a fazer mais sentido, mas ainda não completamente. Veja que cada uma das partes do criado tem o seu mapa equivalente. Por enquanto, a informação mais clara relativa aos mapas está naquele vinculado ao Criado_piso.dae, pois o piso nada mais é do que um objeto simples, com apenas um lado visível. Diferente dos outros que são complexos, formados por várias partes, recortes e reentrâncias.

Essa figura é mais didática. Veja que a imagem bidimensional tem relação com o sólido 3-D. As extremidades do primeiro mapa e modelo foram coloridas para ficar mais evidente a relação. Nos demais mapas apenas foram marcadas as áreas relacionadas as faces dos objetos.

Se você não entendeu o processo, tudo bem, basta saber que cada imagem está vinculada ao .dae que contém os dados espaciais dos sólidos.

Depois dessa explicação pormenorizada vamos ao código em ActionScript.

Crie um arquivo dentro da pasta importar chamado Criado.as

Escreva o seguinte código no seu arquivo:

package
{
 import flash.events.Event;

 import org.papervision3d.view.BasicView;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {


  public function Criado()
  {
   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event); 
  }
 }
}

Esse é a base do nosso visualizador. Vamos por parte para explicar o mais importante do código.

import flash.events.Event;

 import org.papervision3d.view.BasicView;

Aqui importamos as bibliotecas necessárias para visualização do projeto, bem como a visualização básica do Papervision3D que nos permite montar uma cena sem precisar descrever todos os elementos que a compõe. Sem o BasicView o código seria muito maior e inviabilizaria esse tutorial.

[SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]

Essa parte, fixa o tamalho do visualizador em 640×480 pixels, faz o seu background ser branco e fixa 40 quadros por segundo para a animação.

O restante do código ainda não serve para muita coisa. Vamos inserir um dos quatro objetos que a coisa ficará mais clara:

package
{
 import flash.events.Event;
 import flash.display.Bitmap;
 import flash.utils.ByteArray;

 import org.papervision3d.view.BasicView;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {

  [Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;
  
  [Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;

  private var criado_corpo:DAE

  public function Criado()
  {

   var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);
   criado_corpo.scale=250;

   var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

   scene.addChild(criado_corpo);

   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event); 
  }
 }
}

Sim, é bastante código, mas vamos novamente analisá-lo pedaço por pedaço relevante.

import flash.display.Bitmap;
 import flash.utils.ByteArray;

Essas duas bibliotecas são necessárias para:

display.Bitmap -> Poder mostrar as imagens na tela.

utils.ByteArray -> Coletar os dados do arquivo que vamos empacotar (embarcar) no nosso projeto final.

import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;

Perceba que foi separada a parte das bibliotecas nativas do Flash daquelas pertencentes ao Papervision3D.

materials.BitmapMaterial -> Serve para atrelar imagens a uma superfície, ou seja, aquela historinha que contei cobre recortar o papel (aquelas imagens dentro do dir. importar) e colar os pedaços no nosso modelo. Uma coisa interessante é que ela herda algumas funções da Bitmap que usamos logo acima, a possibilidade de ser mostrá-la na tela. Ou seja, uma possibilita que a imagem seja vista e outra recorta ela e cola nos pedaços certos.

parsers.DAE -> Esse carinha é que vai coletar os dados do arquivo Collada (.dae) e convertê-los para um sólido visível via Flash.

[Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;

Aqui ele empacota ou embarca o arquivo Criado_corpo.dae dentro do nosso viasualizador. Existe uma possibilidade de apenas referenciar o arquivo sem precisar inserí-lo. Mas preferi essa situação por dois motivos em ordem de importância:

1) Trazer tudo dentro do arquivo facilita a vida de quem vai carregá-lo.

2) Não obtive sucesso nos meus testes com referenciamento de arquivo… que vergonha 😛

Assim que você empacota o arquivo na cena, é preciso referenciá-lo com uma variável, nesse caso a criado_corpoAsset.

[Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;

Aqui acontece a mesma situação da parte anterior do código. Pegamos a imagem madeira_corpo.jpg e empacotamos ela dentro do nosso visualizador. Assim que você empacota o arquivo na cena, é preciso referenciá-lo com uma variável, nesse caso a materialAsset.

private var criado_corpo:DAE

É criada uma variável private do criado_corpo para que ela possa ser utilizada para um efeito que aplicaremos na sequência.

var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);

Uma abstração é criada para jogar os dados do arquivo empacotado dentro da variável byteArray, logo em seguida, a variável criado_corpo cria um novo DAE, ou seja, um sólido. Os dados desse .dae estão dentro da byteArray, o que o código faz é carregar esses dados com o método .load.

criado_corpo.scale=250;

Para que o objeto tenha uma dimensão agradável aos olhos setamos a sua escala em 250.

var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

Aqui é a vez dos dados da imagem serem carregados, “recortados” e “colados” no sólido 3-D.

criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

Essa parte merece uma observação especial. Veja que em uma dada parte do código aparece a string “madeira_corpo_jpg”.

– Mas por que? Pergunta o leitor atento.

– Não teria que ser “madeira_corpo.jpg”?

Nesse caso, não, e explico por que. Nós importamos os dados de um arquivo Collada (.dae) e dentro dele há uma série de informaçãoes que montam o sólido, setam as pripriedades dele como, posição no espaço tridimensional, animações, texturas e o nome de cada uma dessas configurações.

Se você abrir o arquivo Criado_corpo.dae verá que na tag de material haverá justamente o nome “madeira_corpo_jpg” lá!

scene.addChild(criado_corpo);

Por fim, o criado_corpo é adicionado a cena. Se isso não for feito o código até compila, mas nada aparecerá na cena.

Falando em compilar está na hora de compilar o nosso código para ver o que acontece:

mxmlc -static-link-runtime-shared-libraries Criado.as

E abrirmos o arquivo Criado.swf para saber como ficou.

Muito bom! Renderizou!

Mas está 2-D demais para o nosso gosto, não é mesmo?

Que tal aplicar um efeito de rotação? Vá lá no finalzinho do código, como aparece abaixo:

startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event);

   criado_corpo.rotationY += 0.5; 
  }
 }
}

Adicione a linha verde que aparece logo acima. Recompile o código e reabra o arquivo Criado.swf (ou atualize no browser).

Agora vamos inserir o piso, para que o objeto tenha sombra e fique mais coerente com a realidade:

package
{
 import flash.events.Event;
 import flash.display.Bitmap;
 import flash.utils.ByteArray;

 import org.papervision3d.view.BasicView;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {

  [Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;
  
  [Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;


  [Embed(source="arquivos/Criado_piso.dae", mimeType = "application/octet-stream")]
  private var criado_pisoAsset:Class;
  
  [Embed(source="arquivos/piso.jpg")]
  private var materialPisoAsset:Class;


  private var criado_corpo:DAE
  private var criado_piso:DAE

  public function Criado()
  {

   var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);
   criado_corpo.scale=250;

   var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

   scene.addChild(criado_corpo);


   var byteArrayPiso:ByteArray = new criado_pisoAsset() as ByteArray;
   criado_piso = new DAE();
   criado_piso.load(byteArrayPiso);
   criado_piso.scale=250;

 
   var bitmapPiso:Bitmap = new materialPisoAsset() as Bitmap;
   var bitmapPisoMaterial:BitmapMaterial = new BitmapMaterial(bitmapPiso.bitmapData, true);
   criado_piso.materials.addMaterial(bitmapPisoMaterial, "piso_jpg");

   
   scene.addChild(criado_piso);


   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event);

   criado_corpo.rotationY += 0.5;
   criado_piso.rotationY += 0.5; 
  }
 }
}

Fizemos a mesma coisa que anteiormente, quando colocamos o Criado_corpo.dae na cena. Também aplicamos o efeito de rotação no final, caso contrário, o objeto rodaria e a sombra ficaria parada.

A ordem de colocação dos objetos não precisa serguir a figura que mostrei anteriormente. Você pode começar pela sombra se quiser, ou pela gaveta, ou seja lá o que for. Mas, coloquei a sombra na sequência por motivação didática.

Recompile o código e reabra o arquivo Criado.swf olhando para a sua base, necessariamente onde fica a sombra.

Se tudo der certo, algo sairá errado 🙂

Nesse caso, o errado será um corte desagradável que fará parte da base do criado ficar invisível conforme aparece na figura acima.

Isso acontece por que o tipo de renderização que estamos usando para esse código não é boa o suficiente para lidar com esse tipo de sólido com textura.

Precisaremos fazer uns pequenos ajustes:

package
{
 import flash.events.Event;
 import flash.display.Bitmap;
 import flash.utils.ByteArray;

 import org.papervision3d.view.BasicView;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;
 import org.papervision3d.render.QuadrantRenderEngine;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {

  [Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;
  
  [Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;


  [Embed(source="arquivos/Criado_piso.dae", mimeType = "application/octet-stream")]
  private var criado_pisoAsset:Class;
  
  [Embed(source="arquivos/piso.jpg")]
  private var materialPisoAsset:Class;


  private var criado_corpo:DAE
  private var criado_piso:DAE

  public function Criado()
  {

   var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);
   criado_corpo.scale=250;

   var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

   scene.addChild(criado_corpo);


   var byteArrayPiso:ByteArray = new criado_pisoAsset() as ByteArray;
   criado_piso = new DAE();
   criado_piso.load(byteArrayPiso);
   criado_piso.scale=250;

 
   var bitmapPiso:Bitmap = new materialPisoAsset() as Bitmap;
   var bitmapPisoMaterial:BitmapMaterial = new BitmapMaterial(bitmapPiso.bitmapData, true);
   criado_piso.materials.addMaterial(bitmapPisoMaterial, "piso_jpg");

   
  scene.addChild(criado_piso);

  renderer = new QuadrantRenderEngine(QuadrantRenderEngine.ALL_FILTERS);

   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event);

   criado_corpo.rotationY += 0.5;
   criado_piso.rotationY += 0.5; 
  }
 }
}

Com esses dois ajustes a cena será renderizada sem os problemas de invisibilidade parcial.

import org.papervision3d.render.QuadrantRenderEngine;

Aqui importamos uma biblioteca com um render chamado Quadrant, que faz a visualização aumentar a qualidade em determinadas situações, assim o 3-D não fica tão pesado com subdivisão constante.

renderer = new QuadrantRenderEngine(QuadrantRenderEngine.ALL_FILTERS);

Aqui ele seta a configuração da visualização, substituindo aquela que o BasicView usa como padrão.

Note na base do criado, os pés dele agora estão indo até o piso.

É hora de inserir a porta. Mas deixei uma surpresinha para essa parte. A surpresinha é a seguinte:

A porta está animada, ela abre e fecha!

Daí vem a pergunta inteligente:

– Como animada, você não tem animar no Flash?

De fato, voc? pode animar diretamente no código do visualizador, assim como fizemos com o Corpo_criado e o Criado_piso. Mas o fato é que o Collada dá suporte a animação e você pode animar no programa onde o arquivo foi gerado, nesse caso o Blender, e exportar o Collada com a animação.

Bacana, não?

Vamos ao código com a porta:

package
{
 import flash.events.Event;
 import flash.display.Bitmap;
 import flash.utils.ByteArray;

 import org.papervision3d.view.BasicView;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;
 import org.papervision3d.render.QuadrantRenderEngine;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {

  [Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;
  
  [Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;


  [Embed(source="arquivos/Criado_piso.dae", mimeType = "application/octet-stream")]
  private var criado_pisoAsset:Class;
  
  [Embed(source="arquivos/piso.jpg")]
  private var materialPisoAsset:Class;


  [Embed(source="arquivos/Criado_porta.dae", mimeType = "application/octet-stream")]
  private var criado_portaAsset:Class;
  
  [Embed(source="arquivos/madeira_porta.jpg")]
  private var materialPortaAsset:Class;


  private var criado_corpo:DAE
  private var criado_piso:DAE
  private var criado_porta:DAE

  public function Criado()
  {

   var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);
   criado_corpo.scale=250;

   var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

   scene.addChild(criado_corpo);


   var byteArrayPiso:ByteArray = new criado_pisoAsset() as ByteArray;
   criado_piso = new DAE();
   criado_piso.load(byteArrayPiso);
   criado_piso.scale=250;

 
   var bitmapPiso:Bitmap = new materialPisoAsset() as Bitmap;
   var bitmapPisoMaterial:BitmapMaterial = new BitmapMaterial(bitmapPiso.bitmapData, true);
   criado_piso.materials.addMaterial(bitmapPisoMaterial, "piso_jpg");

   scene.addChild(criado_piso);


  var byteArrayPorta:ByteArray = new criado_portaAsset() as ByteArray;
   criado_porta = new DAE(true, null, true);
   criado_porta.load(byteArrayPorta);
   criado_porta.scale=250;

 
   var bitmapPorta:Bitmap = new materialPortaAsset() as Bitmap;
   var bitmapPortaMaterial:BitmapMaterial = new BitmapMaterial(bitmapPorta.bitmapData, true);
   criado_porta.materials.addMaterial(bitmapPortaMaterial, "madeira_porta_jpg");
   
   scene.addChild(criado_porta);


   renderer = new QuadrantRenderEngine(QuadrantRenderEngine.ALL_FILTERS);

   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event);

   criado_corpo.rotationY += 0.5;
   criado_piso.rotationY += 0.5;
   criado_porta.rotationY += 0.5;
  }
 }
}

Novamente, a forma de inserir não diferiu muito dos últimos elementos, exceto num ponto:

criado_porta = new DAE(true, null, true);

Perceba que depois do DAE aparecem seus atributos dentro do parênteses. No caso, o primeiro true significa que desejamos dar um play automático na animação e o último true significa que é para ficar em loop, ou seja, tocar sem parar.

Nossa porta está radiante de bela, abrindo e fechando eternamente. Agora falta apenas o grand finale, a gaveta, que também está animada!

package
{
 import flash.events.Event;
 import flash.display.Bitmap;
 import flash.utils.ByteArray;

 import org.papervision3d.view.BasicView;
 import org.papervision3d.materials.BitmapMaterial;
 import org.papervision3d.objects.parsers.DAE;
 import org.papervision3d.render.QuadrantRenderEngine;


 [SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="40")]


 public class Criado extends BasicView
 {

  [Embed(source="arquivos/Criado_corpo.dae", mimeType = "application/octet-stream")]
  private var criado_corpoAsset:Class;
  
  [Embed(source="arquivos/madeira_corpo.jpg")]
  private var materialAsset:Class;


  [Embed(source="arquivos/Criado_piso.dae", mimeType = "application/octet-stream")]
  private var criado_pisoAsset:Class;
  
  [Embed(source="arquivos/piso.jpg")]
  private var materialPisoAsset:Class;


  [Embed(source="arquivos/Criado_porta.dae", mimeType = "application/octet-stream")]
  private var criado_portaAsset:Class;
  
  [Embed(source="arquivos/madeira_porta.jpg")]
  private var materialPortaAsset:Class;


  [Embed(source="arquivos/Criado_gaveta.dae", mimeType = "application/octet-stream")]
  private var criado_gavetaAsset:Class;
  
  [Embed(source="arquivos/madeira_gaveta.jpg")]
  private var materialGavetaAsset:Class;


  private var criado_corpo:DAE
  private var criado_piso:DAE
  private var criado_porta:DAE
  private var criado_gaveta:DAE


  public function Criado()
  {

   var byteArray:ByteArray = new criado_corpoAsset() as ByteArray;
   criado_corpo = new DAE();
   criado_corpo.load(byteArray);
   criado_corpo.scale=250;

   var bitmap:Bitmap = new materialAsset() as Bitmap;
   var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
   criado_corpo.materials.addMaterial(bitmapMaterial, "madeira_corpo_jpg");

   scene.addChild(criado_corpo);


   var byteArrayPiso:ByteArray = new criado_pisoAsset() as ByteArray;
   criado_piso = new DAE();
   criado_piso.load(byteArrayPiso);
   criado_piso.scale=250;

 
   var bitmapPiso:Bitmap = new materialPisoAsset() as Bitmap;
   var bitmapPisoMaterial:BitmapMaterial = new BitmapMaterial(bitmapPiso.bitmapData, true);
   criado_piso.materials.addMaterial(bitmapPisoMaterial, "piso_jpg");

   scene.addChild(criado_piso);


   var byteArrayPorta:ByteArray = new criado_portaAsset() as ByteArray;
   criado_porta = new DAE(true, null, true);
   criado_porta.load(byteArrayPorta);
   criado_porta.scale=250;

 
   var bitmapPorta:Bitmap = new materialPortaAsset() as Bitmap;
   var bitmapPortaMaterial:BitmapMaterial = new BitmapMaterial(bitmapPorta.bitmapData, true);
   criado_porta.materials.addMaterial(bitmapPortaMaterial, "madeira_porta_jpg");
   
   scene.addChild(criado_porta);


   var byteArrayGaveta:ByteArray = new criado_gavetaAsset() as ByteArray;
   criado_gaveta = new DAE(true, null, true);
   criado_gaveta.load(byteArrayGaveta);
   criado_gaveta.scale=250;

 
   var bitmapGaveta:Bitmap = new materialGavetaAsset() as Bitmap;
   var bitmapGavetaMaterial:BitmapMaterial = new BitmapMaterial(bitmapGaveta.bitmapData, true);
   criado_gaveta.materials.addMaterial(bitmapGavetaMaterial, "madeira_gaveta_jpg");
   
   scene.addChild(criado_gaveta);


   renderer = new QuadrantRenderEngine(QuadrantRenderEngine.ALL_FILTERS);

   startRendering();
  }


  override protected function onRenderTick(event:Event = null):void 
  {
   super.onRenderTick(event);

   criado_corpo.rotationY += 0.5;
   criado_piso.rotationY += 0.5;
   criado_porta.rotationY += 0.5;
   criado_gaveta.rotationY += 0.5;
  }
 }
}

Compile novamente e vamos ver o resultado final:

Aí está! O criado rústico pronto e você um pouco mais informado acerca de 3-D para Flash usando ferramentas livres na contrução e compilação.