Come abbiamo visto in precedenza, per il linguaggio Actionscript sono stati creati diversi motori per la gestione della grafica poligonale, quello su cui ci siamo soffermati è Sandy 3D Engine.

Sandy 3D Engine offre la possibilità di utilizzare all’interno delle applicazioni dei modelli poligonali realizzati con applicazioni esterne. Basicamente esistono due metodi per ottenere questo risultato:

• utilizzare direttamente il formato dell’applicazione esterna
• esportare il modello poligonale in una classe AS3 che successivamente istanzieremo.

In questo tutorial prenderemo in considerazione la seconda di queste possibilità, ovvero useremo un plugin per 3D Studio Max che esporterà il modello poligonale, l’AS3 Geom Class Exporter, plugin sviluppato da Seraf aka Jerome Birembaut, che potete scaricare da questo link. Da notare che il plugin in questione è compatibile anche con Papervision e Away3D.

Installare AS3 Geom Class Exporter

Per installare lo script estraete il contenuto dell’archivio, quindi da 3DStudio selezionare la tab Utilities, selezionare il pannello maxscript e cliccare il bottone “Run Script”. Selezionate lo script estratto, quindi il pannello “AS3 geom Exporter” sarà disponibile.

Le opzioni dello script sono le seguenti

• Package : il nome del package della classe esportata, lasciatelo pure vuoto
• ClassName : il nome della classe esportata
• Engine : il 3D engine che volete usare
• Scale : per scalare l’oggetto 3D
• Export Vertex Normal
• Swap face normal : per alcuni oggetti può capitare di avere le facce invertite. Se succede utilizzare questa opzione
• Rounded Vertex coord

Utilizzare l’oggetto 3D

Una volta esportato l’oggetto potremo finalmente utilizzarlo all’interno della nostra applicazione istanziandolo. Potete scaricare qui di seguito il risultato di una esportazione di un modello di una navicella spaziale ispirata all’Arwing ( Starfox ) creata dal sottoscritto:

Download Arwing.as

A questo punto non ci resta che creare la classe Point of Entry comprensiva del codice che serve per inizializzare il motore 3D, che risulterà così:

  package
  {
    import flash.display.Sprite;
    import flash.events.*;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;  

    public class MainClass extends Sprite
    {
      private var player:Arwing;
      private var scene:Scene3D;
      private var camera:Camera3D;
      private var group:Group;  

      public function MainClass(){
        group = new Group("root");
        camera = new Camera3D( 550, 400 );
        scene = new Scene3D( "myScene", this, camera, group);
        player = new Arwing("player");
        scene.root.addChild(player);
        addEventListener( Event.ENTER_FRAME, enterFrameHandler );
      }

      private function enterFrameHandler( event : Event ):void {
        scene.render();
        player.rotateX -=2;
        player.rotateY -=4;
      }
    }
  }

Il risultato ottenuto sarà il seguente:

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

I modelli MD2 sono dei particolari files introdotti dalla Id Software nel gioco Quake 2 nel novembre 1997. E’ un formato di semplice comprensione contenente dei modelli poligonali e le relative animazioni frame by frame. Per chi volesse saperne di più segnalo questo link contenente tutte le spiegazioni tecniche.

Come sempre ecco qui il risultato finale:

Il nostro modello importato viene visualizzato nel filmato. I comandi attivi si limitano a richiamare le varie animazioni contenute nel file MD2, per semplicità non ho aggiunto la possibilità di muoversi nello spazio 3D. Premete i tasti numerici sulla vostra tastiera per vedere il personaggio compiere varie animazioni.

Questo invece è il codice sorgente

  package {
    import flash.display.*;
    import flash.events.*;
    import flash.net.*;
    import flash.utils.*;
    import flash.ui.*;

    import sandy.util.*;
    import sandy.core.Scene3D;
    import sandy.core.data.*;
    import sandy.core.scenegraph.*;
    import sandy.materials.*;
    import sandy.materials.attributes.*;
    import sandy.primitive.*;
    import sandy.events.*;

    import caurina.transitions.Tweener;

    public class SandyMain extends Sprite {
      private var scene:Scene3D;
      private var camera:Camera3D;
      private var queue:LoaderQueue;
      private var queueSkin:LoaderQueue;
      private var player:MD2;

      public function SandyMain() {
        queue = new LoaderQueue();
        queue.add( "ogre", new URLRequest("md2/ogre.md2"), "BIN" );
        queue.add( "ogreSkin", new URLRequest("md2/Ogrobase.jpg"), "IMG" );
        queue.addEventListener(SandyEvent.QUEUE_COMPLETE, loadMD2Complete );
        queue.start();
      }

      private function loadMD2Complete(event:Event):void {
        stage.frameRate = 24;
        camera = new Camera3D( 600, 600 );
        scene = new Scene3D( "scene", this, camera, new Group() );
        player = new MD2 ( "ogre", queue.data["ogre"], 2 );
        player.appearance = new Appearance (new BitmapMaterial( queue.data["ogreSkin"].bitmapData ));
        player.x = 0;
        player.y = 0;
        player.rotateY = 270;
        scene.root.addChild(player);
        standAction();
        stage.addEventListener( Event.ENTER_FRAME, enterFrameListener );
        stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownListener );
        stage.addEventListener(KeyboardEvent.KEY_UP, keyUpListener );
      }

      private function keyDownListener( event : KeyboardEvent ):void {
        var char : String = String.fromCharCode(event.charCode);
        if (char == '1') {
          standAction();
        }
        if (char == '2') {
          waveAltAction();
        }
        if (char == '3') {
          attackAction();
        }
        if (char == '4') {
          deathTwoAction();
        }
        if (char == '5') {
          sniffSniffAction();
        }
        if (char == '6') {
          cWalkAction();
        }
        if (char == '7') {
          bumFlopAction();
        }
        if (char == '8') {
          flipAction();
        }
        if (char == '9') {
          saluteAction();
        }
        if (char == '0') {
          jumpAction();
        }
      }

      private function keyUpListener( event : KeyboardEvent ):void {
        var char : String = String.fromCharCode(event.charCode);
        if (event.keyCode == Keyboard.ENTER) {
          player.x = 0;
          player.y = 0;
          player.z = 100;
        }
      }

      private function enterFrameListener( event : Event ) : void {
        scene.render();
      }

      /*
      standAction()
      runAction()
      attackAction()
      painOneAction()
      painTwoAction()
      painThreeAction()
      jumpAction()
      flipAction()
      saluteAction()
      bumFlopAction()
      waveAltAction()
      sniffSniffAction
      cStandAction
      cWalkAction
      crAttachAction
      crPainAction
      crDeathAction
      deathOneAction
      deathTwoAction
      deathThreeAction()
      boomAction()
      */

      private function standAction():void {
        player.frame = 0;
        Tweener.addTween (player, { frame: 39, time: 8, onComplete: standAction });
      }

      private function runAction():void {
        player.frame = 40;
        Tweener.addTween (player, { frame: 45, time: 0.3, onComplete: runAction  });
      }

      private function attackAction():void {
        player.frame = 46;
        Tweener.addTween (player, { frame: 53, time: 1});
      }

      private function painOneAction():void {
        player.frame = 54;
        Tweener.addTween (player, { frame: 57, time: 1});
      }

      private function painTwoAction():void {
        player.frame = 58;
        Tweener.addTween (player, { frame: 61, time: 1});
      }

      private function painThreeAction():void {
        player.frame = 62;
        Tweener.addTween (player, { frame: 65, time: 1});
      }

      private function jumpAction():void {
        player.frame = 66;
        Tweener.addTween (player, { frame: 71, time: 1});
      }

      private function flipAction():void {
        player.frame = 72;
        Tweener.addTween (player, { frame: 83, time: 1});
      }

      private function saluteAction():void {
        player.frame = 84;
        Tweener.addTween (player, { frame: 94, time: 1});
      }

      private function bumFlopAction():void {
        player.frame = 95;
        Tweener.addTween (player, { frame: 111, time: 1});
      }

      private function waveAltAction():void {
        player.frame = 112;
        Tweener.addTween (player, { frame: 122, time: 1});
      }

      private function sniffSniffAction():void {
        player.frame = 123;
        Tweener.addTween (player, { frame: 134, time: 1});
      }

      private function cStandAction():void {
        player.frame = 135;
        Tweener.addTween (player, { frame: 153, time: 1});
      }

      private function cWalkAction():void {
        player.frame = 154;
        Tweener.addTween (player, { frame: 159, time: 1});
      }

      private function crAttachAction():void {
        player.frame = 160;
        Tweener.addTween (player, { frame: 168, time: 1});
      }

      private function crPainAction():void {
        player.frame = 169;
        Tweener.addTween (player, { frame: 172, time: 1});
      }

      private function crDeathAction():void {
        player.frame = 173;
        Tweener.addTween (player, { frame: 177, time: 1});
      }

      private function deathOneAction():void {
        player.frame = 178;
        Tweener.addTween (player, { frame: 183, time: 1});
      }

      private function deathTwoAction():void {
        player.frame = 184;
        Tweener.addTween (player, { frame: 189, time: 1});
      }

      private function deathThreeAction():void {
        player.frame = 190;
        Tweener.addTween (player, { frame: 197, time: 1});
      }

      private function boomAction():void {
        player.frame = 198;
      }

    }
  }

E adesso addentriamoci nelle dovute spiegazioni. Come detto nel titolo di questo articolo utilizzeremo nel nostro codice la classe Tweener della libreria caurina. Quindi il primo consiglio è scaricare le librerie necessarie, a questo scopo vi consiglio di utilizzare un client svn ed inserire la seguente url di checkuot: http://tweener.googlecode.com/svn/trunk. Scaricherete nella cartella selezionata le librerie aggiornate. Tra le varie sottodirectories che compongono il contenuto del vostro download sarà presente una directory chiamata ‘as3′, che aggiungerete alle librerie di flash ( Modifica -> Preferenze -> Actionscript -> Impostazioni Actionscript 3.0 ).

La classe Tweener

Tweener (caurina.transitions.Tweener) è una classe usata per creare tweenings e altre transizioni via codice ActionScript piuttosto che usando la timeline di flash. Questo comporta una maggiore semplicità nella gestione del codice. L’utilizzo che ne faremo in questo articolo si limita a questo genere di chiamata

      private function attackAction():void {
        player.frame = 46;
        Tweener.addTween (player, { frame: 53, time: 1});
      }

ovvero diciamo alla classe Tweener di arrivare al frame 53 dell’oggetto player ( che è il nostro MD2 che contiene, come abbiamo detto, una moltitudine di frames di animazione ). Il frame di partenza lo settiamo giusto 1 istante prima di questa chiamata in modo da ottenere la visualizzazione dell’animazione desiderata.

Viene naturale porsi una domanda, come faccio a sapere una certa animazione da quale frame parte e a quale frame arriva? La risposta a questa domanda è utilizzando un model editor. Più esattamente io ho utilizzato un programma chiamato Quake Model Editor. Questo programma è inizialmente sviluppato da Philip Martin, purtroppo il sito di riferimento è stato sostituito con altro, quindi lo metto in download da questo link.

Questo leggerissimo applicativo assomiglia vagamente a 3DStudio Max e vi da la possibilità di visualizzare i files MD2 e vedere le animazioni frame per frame.

Importazione del file MD2

Un oggetto MD2 in Sandy 3D Engine è gestito dall’omonima class, MD2 appunto. Tralasciando quindi il costruttore che utilizzeremo per caricare tutti i files necessari, arriviamo al metodo loadMD2Complete dove istanziamo un oggetto MD2, passando al costruttore il nome dell’oggetto, l’oggetto MD2 caricato e il fattore di scala. Quindi lo aggiungiamo nello stage.

I controlli

Potete controllare un oggetto MD2 come un qualsiasi altro componente di Sandy3D, quindi modificando le proprietà x, y, z ecc.. In questo tutorial tuttavia non mi addentrerò più di tanto nei controlli del personaggio nello spazio 3D, in ogni caso nel codice sono comprese tutte le animazioni del contenute nel file MD2, ognuna di esse è un metodo della classe. Il codice attuale mostra 10 delle 21 animazioni presenti ( una per tasto numerico ) per provare a vedere le altre non vi resta che modificare il codice. Se un’animazione viene visualizzata troppo velocemente o lentamente il consiglio è di modificare il valore per la proprietà ‘time’.

Cliccando su questo link potete scaricare il codice sorgente comprensivo del file MD2.

Prima di concludere voglio segnalarvi un link interessante per recuperare dei modelli MD2, polycount.com.

Si conclude qui il tutorial, comment, rate and share!

Related posts:

1. Esportare modelli poligonali con AS3 Geom Class Exporter Utilizziamo modelli poligonali realizzati con 3DStudio Max in Flash Come...
2. Muovere uno sprite usando la tastiera con Actionscript 3.0 Muoviamo un oggetto alla pressione dei tasti. In questo articolo...
3. Personalizzare il puntatore del mouse con Actionscript 3.0 Usando la classe Custom Mouse Pointer Per le nostre applicazioni...

Related posts brought to you by Yet Another Related Posts Plugin.

Uno skybox è una sorta i contenitore formato da 6 piani che ha la funzione di far da fondale per una applicazione 3D. Il framework Sandy 3D Engine ha un omonimo oggetto che gestisce in maniera molto semplice tutto ciò e, in questo tutorial, vedremo come utilizzarlo e come eventualmente effettuare uno switch delle texture per ognuna delle sue faccie. Inoltre, utilizzeremo un diverso sistema rispetto a quello usato in questo tutorial per caricare i file esterni all’interno del nostro programma, l’oggetto LoaderQueue.

Per la creazione delle texture possiamo utilizzare il software Terragen o cercare sul solito motore di ricerca.

SandyMain.as

  package {
    import flash.display.Sprite;
    import flash.events.*;
    import flash.ui.*;
    import flash.display.Bitmap;
    import flash.net.URLRequest;

    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
    import sandy.materials.*;
    import sandy.materials.attributes.*;
    import sandy.events.*;
    import sandy.util.*;

    public class SandyMain extends Sprite {
      private static const TOP = 'top';
      private static const LEFT = 'left';
      private static const BOTTOM = 'bottom';
      private static const RIGHT = 'right';
      private static const BACK = 'back';
      private static const FRONT = 'front';

      private var scene:Scene3D;
      private var camera:Camera3D;
      private var group:Group;
      private var queue:LoaderQueue;
      private var skyBox:SkyBox;    

      public function SandyMain():void {
        group = new Group("root");
        camera = new Camera3D( 1024, 768);
        camera.setPosition(0,0,0);
        scene = new Scene3D( "myScene", this, camera, group);
        skyBox  = new SkyBox( "container", 1000, 9, 9 );
        loadSkyTextures();
        group.addChild( skyBox );
      }

      private function loadSkyTextures(type:String = 'default'):void {
        queue = new LoaderQueue();
        queue.add( TOP, new URLRequest("assets/skybox/"+type+"/top.jpg") );
        queue.add( LEFT, new URLRequest("assets/skybox/"+type+"/left.jpg") );
        queue.add( BOTTOM, new URLRequest("assets/skybox/"+type+"/bottom.jpg") );
        queue.add( RIGHT, new URLRequest("assets/skybox/"+type+"/right.jpg") );
        queue.add( BACK, new URLRequest("assets/skybox/"+type+"/back.jpg") );
        queue.add( FRONT, new URLRequest("assets/skybox/"+type+"/front.jpg") );
        queue.addEventListener(SandyEvent.QUEUE_COMPLETE, loadComplete );
        queue.start();
      }

      private function setAppearance():void {
        var mTop = new BitmapMaterial( queue.data[TOP].bitmapData, null );
        var mLeft = new BitmapMaterial( queue.data[LEFT].bitmapData );
        var mBottom = new BitmapMaterial( queue.data[BOTTOM].bitmapData );
        var mRight = new BitmapMaterial( queue.data[RIGHT].bitmapData );
        var mBack = new BitmapMaterial( queue.data[BACK].bitmapData );
        var mFront = new BitmapMaterial( queue.data[FRONT].bitmapData );
        skyBox.top.appearance = new Appearance( mTop );
        skyBox.left.appearance = new Appearance( mLeft );
        skyBox.bottom.appearance = new Appearance( mBottom );
        skyBox.right.appearance = new Appearance( mRight );
        skyBox.back.appearance = new Appearance( mBack );
        skyBox.front.appearance = new Appearance( mFront );
      }

      private function loadComplete( event : QueueEvent ):void {
        setAppearance();
        addEventListener( Event.ENTER_FRAME, enterFrameHandler );
        stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
      } 

      private function enterFrameHandler( event : Event ):void {
        scene.render();
      } 

      private function keyPressed(event:KeyboardEvent):void {
        switch(event.keyCode) {
          case Keyboard.UP:
            camera.tilt +=2;
            //camera.rotateX -=2;
            break;
          case Keyboard.DOWN:
            camera.tilt -=2;
            //camera.rotateX +=2;
            break;
          case Keyboard.RIGHT:
            //camera.pan +=2;
            camera.rotateY -=2;
            break;
          case Keyboard.LEFT:
            //camera.pan -=2;
            camera.rotateY +=2;
            break;
          case Keyboard.CONTROL:
            camera.roll +=2;
          break;
          case 48:
            loadSkyTextures();
          break;
          case 49:
            loadSkyTextures('skybox');
          break;
        }
      }
    }
  }

Nel costruttore creaimo tutto ciò di cui necessita Sandy 3D engine con in aggiunta l’oggetto skybox. Attribuiremo una diversa texture per ogni faccia tramite la chiamata del metodo loadSkyTextures(), al quale sarà possibile passare un argomento: il nome della subdirectory dove andare a cercare i files da caricare. Da notare il codice che compone questo metodo, dove facciamo uso dell’oggetto LoaderQueue.

LoaderQueue si occupa di caricare i file specificati tramite il metodo add(), è una volta terminato esegue il dispatch dell’evento SandyEvent.QUEUE_COMPLETE che richiama il metodo setAppearance() che si occupa di rivestire ogni singola faccia con la relativa immagine.

Con questa impostazione eseguire una switch delle texture di ogni faccia è molto semplice. Alla pressione di un tasto ( in questo caso sono stati utilizzati i tasti numerici 0 e 1 ) effettuiamo una chiamata al metodo loadSkyTextures(); in cui passeremo un argomento diverso dipendentemente da quale rivestimento vogliamo far visualizzare alla pressione di quel tasto.

Qui di seguito il risultato finale:

Related posts:

1. Muovere uno sprite usando la tastiera con Actionscript 3.0 Muoviamo un oggetto alla pressione dei tasti. In questo articolo...
2. Esportare modelli poligonali con AS3 Geom Class Exporter Utilizziamo modelli poligonali realizzati con 3DStudio Max in Flash Come...
3. Personalizzare il puntatore del mouse con Actionscript 3.0 Usando la classe Custom Mouse Pointer Per le nostre applicazioni...

Related posts brought to you by Yet Another Related Posts Plugin.

L’esempio che tratterò in questo articolo sarà quanto di più semplice è possibile realizzare utilizzando questo framework, una sfera texture-mappata rappresentante il pianeta Terra, con in più qualche comando tipo la rotazione negli assi X,Y,Z ed alcuni movimenti della telecamera virtuale.
Se siete pronti non vi resta che scaricare Sandy 3D Engine.

Lo potete trovare in download su http://www.flashsandy.org/download.

Per i più impazienti, qui sotto potete vedere il risultato finale. Niente male per poche righe di codice, che ne dite?

Usate i tasti 1,2,3,4,5,6 per muovere rispettivamente la Terra nel suo asse X ( 1 e 2 ), Y ( 3 e 4 ) e Z ( 5 e 6 ), inoltre i tasti PAG UP e PAG DOWN per avvicinare ed allontanare la camera virtuale e i tasti direzionali per muovere sempre la camera direzionale nelle relative direzioni.

Prima di cominciare bisogna ‘dire’ a Flash dove andare a prendere le librerie di Sandy 3D engine in modo tale che quando le richiameremo nell’applicazione non ci venga restituito un bell’errore. Quindi, dopo aver scaricato Sandy 3D engine, apriamo flash, nel menu in alto selezioniamo Modifica -> Preferenze ( CTRL+U ), dopodichè selezioniamo Actionscript, clicchiamo su Impostazioni Actionscript 3.0 e selezioniamo la directory in cui abbiamo i file di flash Sandy 3D Engine. Attenzione in questo passaggio, in quanto la directory da selezionare dev’essere quella che contiene al suo interno la directory Sandy ( es. il_mio_percorso/src/ dove src conterrà Sandy ).

Ogni applicazione che utilizza Sandy 3D engine è composta principalmente da questi oggetti:

• Una scena 3D, ovvero il mondo 3D
• Un gruppo, ovvero un oggetto che conterrà tutti gli altri oggetti
• Una camera 3D

Il seguente è il codice completo di questa applicazione, ovvero della sfera texture-mappata, del loop dell’applicazione e dell’interazione dei comandi della tastiera:

package {
    import flash.display.Sprite;
    import flash.events.*;
    import sandy.core.Scene3D;
    import sandy.core.scenegraph.*;
    import sandy.primitive.*;
    import sandy.materials.*;
    import flash.ui.*;

    public class Sfera extends Sprite {
      private var sfera:Sphere;
      private var scene:Scene3D;
      private var camera:Camera3D;
      private var group:Group;

      public function Sfera():void {
        group = new Group("root");
        camera = new Camera3D( 550, 400 );
        scene = new Scene3D( "myScene", this, camera, group);
        sfera = new Sphere( "mySphere",100,24,18 );
        sfera.appearance = new Appearance(  new BitmapMaterial( new Texture(0,0) ) );
        scene.root.addChild(sfera);
        addEventListener( Event.ENTER_FRAME, enterFrameHandler );
        stage.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);
      }

      private function enterFrameHandler( event : Event ):void {
        scene.render();
      } 

      private function keyPressed(event:KeyboardEvent):void {
        switch(event.keyCode) {
          case Keyboard.UP:
            camera.tilt +=2;
            break;
          case Keyboard.DOWN:
            camera.tilt -=2;
            break;
          case Keyboard.RIGHT:

            camera.pan -=2;
            break;
          case Keyboard.LEFT:
            camera.pan +=2;
            break;
          case Keyboard.CONTROL:
            camera.roll +=2;
            break;
          case Keyboard.PAGE_DOWN:
            camera.z -=5;
            break;
          case Keyboard.PAGE_UP:
            camera.z +=5;
          break;
          case 49:
            sfera.rotateX+=1;
          break;
          case 50:
            sfera.rotateX-=1;
          break;
          case 51:
            sfera.rotateY+=1;
          break;
          case 52:
            sfera.rotateY-=1;
          break;
          case 53:
            sfera.rotateZ+=1;
          break;
          case 54:
            sfera.rotateZ-=1;
          break;
        }
        trace(event.keyCode);
      }
    }
  }

Dalla riga 2 alla riga 8 importiamo tutte le librerie di cui abbiamo bisogno.

Dalla riga 11 alla 14 creaiamo le proprietà private che conterranno gli oggetti fondamentali con in aggiunta la sfera.

La funzione enterFrameHandler è quella che viene richiamata in ogni singolo frame, e non a caso renderizza la scena.

La funzione keyPressed viene richiamata ogni qual volta un tasto della tastiera è premuto. Se il keycode della tastiera corrisponde ad uno dei casi, l’azione relativa viene eseguita.

All’interno della funzione keyPressed ho aggiunto trace(event.keyCode); che ci permette di visualizzare il keycode del tasto premuto ( un numero intero ).

L’unico punto su cui dobbiamo soffermarci riguarda l’inserimento della texture all’interno dell’applicazione. Questa, una volta scelta ( qui ne trovate a volontà ), deve essere importata nella libreria ( File -> apri … vi ricordo CTRL+L per visulizzare la libreria ) e concatenata ad una classe.

Per eseguire questa operazione, selezioniamo il file dalla libreria, destro del mouse e selezioniamo la voce concatenamento. Fatto cio attribuiamo un nome classe alla texture, nel nostro caso il nome sarà proprio Texture ( la maiuscola è FONDAMENTALE ). Se visualizzate il codice alla riga 21, è proprio una istanza di Texture ( quindi di questa immagine ) che passiamo come argomento all’istanza di BitmapMaterial. Inoltre devono essere spuntati ‘Esporta per Actionscript’ ed ‘Esporta nel primo fotogramma’.

Per compilare questa applicazione vi ricordo che dovete creare un nuovo documento flash ( linguaggio AS3 ), creare un file chiamato col medesimo nome della classe, Sfera nel nostro caso, con estensione .as e legarlo al documento inserendo il nome della classe, Sfera all’interno del campo input di testo in proprietà -> classe documento.

Termina qui questo tutorial di base per il framework Flash Sandy 3D engine. I feedback sono sempre ben accetti quindi se avete domande e/o commenti potete scrivere qui sotto.

Related posts:

1. Muovere uno sprite usando la tastiera con Actionscript 3.0 Muoviamo un oggetto alla pressione dei tasti. In questo articolo...
2. Esportare modelli poligonali con AS3 Geom Class Exporter Utilizziamo modelli poligonali realizzati con 3DStudio Max in Flash Come...
3. Personalizzare il puntatore del mouse con Actionscript 3.0 Usando la classe Custom Mouse Pointer Per le nostre applicazioni...

Related posts brought to you by Yet Another Related Posts Plugin.