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.

L’avvento della terza versione di questo linguaggio di programmazione mi ha convinto ad approfondire l’argomento, considerate anche le nuove features offerte.

Actionscript 3.0 è un linguaggio orientato agli oggetti la cui sintassi ricorda molto linguaggi di programmazione come Java e C#. Il cuore del linguaggio è basato sulle specifiche date dall’ECMAScript 4, esattamente come succede per il linguaggio Javascript. Potete trovare la documentazione ufficiale di Actionscript 3 ( che per comodità chiamerò d’ora in poi AS3 ) cliccando su questo link.

Inoltre potete trovare a questo indirizzo la pagina ufficiale del progetto Tamarin il cui obiettivo è quello di fornire una implementazione di ECMAScript 4th edition (ES4).

Per compilare il codice AS3 avrete bisogno di Adobe Flash CS3 ( Flash versione 9 ) o in alternativa di Adobe Flex Builder o ancora di Adobe Flex 2 SDK.

Per questa guida userò Adobe Flash CS3. Pronti?

Le basi del linguaggio

Cercherò di essere il più sintetico possibile nelle spiegazioni senza dilungarmi più di tanto su un singolo punto. Per la comprensione di questo articolo dovreste avere qualche conoscenza di base di programmazione generale, quantomeno sapere che cosa è una variabile, che cosa è un array, una funzione. Per chi avesse bisogno di approfondimenti su alcune features è pregato di lasciare un commento in fondo all’articolo. Il linguaggio AS3 è un linguaggio completamente Object Oriented. Questo che cosa significa? Che per utilizzarlo dovete avere una idea di cosa è un oggetto, ma ancora prima di cosa è una classe.

Classi e Oggetti

Immaginate un’automobile. Essa è composta da moltissimi pezzi al suo interno e non: la carrozzeria, il motore, il volante, il serbatoio ecc ecc.. ed ogni singola parte ha bisogno di un progetto prima di essere costruita. Semplificato al massimo questo è il concetto che sta dietro alle classi e gli oggetti. Le classi sono il progetto e gli oggetti sono le istanze delle classi.

Gli oggetti all’interno di AS3 come in qualsiasi altro linguaggio di programmazione possono essere creati da zero, e prendono il nome di Custom Classes, ma ne esistono altri già pronti all’uso facenti parte del linguaggio, le Built-in Classes. Creare un’applicazione utilizzando classi e oggetti pende il nome di Programmazionead Oggetti ( OOP – Object Oriented Programming ). Le seguenti sono le classi built-in di AS3:

• String Rappresenta del testo ( ad esempio un nome )
• Boolean Rappresenta gli stati true e false ( vero e falso )
• Number Rappresenta numeri in virgola mobile
• int Rappresenta numeri interi
• uint Rappresenta numeri interi positivi
• Array Rappresenta una lista ordinata
• Error Rappresenta un errore del programma ( ad esempio un errore di sintassi )
• Date Rappresenta uno specifico punto nel tempo
• Math Contiene le più comuni funzionalità matematiche
• RegExp Definisce dei tool per trovare e sostituire del testo
• Function Rappresenta del codice che può essere riusato
• Object Definisce ogni funzionalità di base di ogni oggetto Actionscript

Packages

Ogni classe, sia custom che built-in farà parte di un package. Un package è un contenitore di classi che gestiscono una porzione indipendente del programma. Chiameremo il package della nostra applicazione di prova zoo e chiameremo la classe VirtualZoo.Detto ciò, il seguente è un esempio di codice che sarà contenuto all’interno del file che gestisce una classe:

package zoo{
  import flash.display.Sprite;
  class VirtualZoo extends Sprite{
    public function VirtualZoo(){
      // codice
    }
  }
}

La classe VirtualZoo è la main class della nostra applicazione, chiamata anche class point of entry. Questa deve necessariamente estendere la built-in class Sprite, che quindi deve essere importata all’interno del nostro pacchetto zoo (import flash.display.Sprite;). Essendo VirtualZoo una classe del pacchetto zoo il suo percorso completo, conosciuto come fully qualified class name sarà zoo.VirtualZoo. Il metodo omonimo presente al suo interno è il costruttore della classe, ovvero quel codice che viene eseguito appena la classe è istanziata. Come per diversi altri programmi di programmazione il commento su una unica linea è possibile grazie all’uso di // mentre il commento su più linee sara /* commento */.

Per convenzione i nomi della classi vanno sempre con la prima lettera maiuscola, ed in caso di nomi composti si userà il CamelCase.

L’organizzazione delle directories dove risiedono i sorgenti del programma è fondamentale per il suo utilizzo. Per la struttura che ho appena spiegato sarà la seguente:

• VirtualZoo
  • src
    • zoo

La directory src ’sources’ è dove risiederanno i sorgenti del programma. Il prossimo passo è creare un nuovo documento flash e linkarlo alla classe che abbiamo appena creato, ma ancor prima creare il file della classe VirtualZoo. Dirigiamoci quindi all’interno della directory zoo, creiamo un file di testo e rinominiamolo in VirtualZoo.as. Quindi all’interno della directory src e creiamo un nuovo file, VirtualZoo.fla ( tasto destro del mouse -> nuovo -> documento Flash ). Clicchiamo due volte il file appena creato e quindi selezioniamo la voce ‘documento Actionscript 3.0′, clicchiamo sul label proprietà ( dovrebbe trovarsi in basso a sinistra ) e dove vedete il testo ‘Classe documento’ con a fianco un input di testo inserite zoo.VirtualZoo ( senza estenzione as!! ) e cliccate la matitina. Se avete fatto tutto correttamente il contenuto del file sarà importato all’interno di flash, altrimenti riceverete un messaggio di errore.

Access Modifiers

Gli Access Modifiers sono degli attributi che posso essere utilizzati per le classi, le proprietà e i metodi al suo interno. Gli Access Modifiers sono 4, ovvero public, internal, private e protected. Una classe a cui non viene specificato un access modifier è per default internal ovvero può essere accessibile da tutte le altre classi contenute nello stesso pacchetto e solo da queste. Specificare internal per una classe ha come unico scopo quello di chiarire l’effettivo utilizzo che il programmatore ne vuole fare. Se volessimo rendere disponibile la classe per le classi degli altri pacchetti bisognerebbe definirla come public.

Come già detto, gli Access Modifiers possono essere utilizzati anche per i metodi e le proprietà. Utilizzare public per un metodo o una proprietà indica che quel metodo o proprietà è disponibile in qualsiasi zona del programma, internamente o esternamente alla classe in cui si trova. Definire proprietà e metodi con private indica che quel metodo o proprietà saranno disponibili esclusivamente all’interno della stessa classe. Infine protected è un access modifier somigliante a private, la loro differenza risiede nell’accesso da parte delle classi figlie. Un metodo o proprietà definito come protected non sarà disponibile all’esterno della classe ( esattamente come per private ), ma sarà disponibile per le classi che estendono la classe in cui il metodo o la proprietà definita protected risiedono.

Tipi di dato

I tipi di dato, o anche datatypes, definiscono un set di valori. I datatype disponibili in actionscript sono fondamentalmente tre: Null, void e Object. I primi due possono avere rispettivamente il valore di null e undefined, mentre Object include il datatype di ogni istanza di ogni classe. Inoltre ogni built-in o custom classes definiscono il loro tipo di dato. Detto così ha poco senso passiamo quindi a mettere in pratica il concetto di datatype aggiungendo qualche nuova classe al nostro programma di prova.
In uno zoo saranno presenti degli animali e questi animali avranno bisogno di mangiare. Procediamo quindi con la creazione della classe VirtualPet, della classe Food e delle sottoclassi Apple e Sushi.

VirtualPet.as

 // VirtualPet class
  package zoo
  {
    import flash.utils.setInterval;
    import flash.utils.clearInterval;

    internal class VirtualPet
    {
      private static var maxNameLength:int = 20;
      private static var maxCalories:int = 2000;
      // Le calorie che consuma durante la digestione
      private static var caloriesPerSecond:int = 100;

      private var petName:String;
      private var currentCalories:int = 1000;
      // Id del set interval per la digestione
      private var digestIntervalID:int;

      //private var creationTime;

      public function VirtualPet(name:String):void
      {
        //creationTime = new Date();
        setName(name);
        digestIntervalID = setInterval(digest, 1000);
      }

      // setter method AKA mutator method, from AS3.0 modifier method
      public function eat(foodItem:Food):void
      {
        // If this pet is dead...
        if (currentCalories == 0)
        {
          // ...quit this method without modifying currentCalories
          trace(getName() + " is dead. You can't feed it.");
          return;
        }

        if (foodItem is Apple)
        {
          if (Apple(foodItem).hasWorm())
          {
            trace("The " + foodItem.getName() + " had a worm. " + getName()
                  + " didn't eat it.");
            return;
          }
        }

        var newCurrentCalories:int = currentCalories + foodItem.getCalories();
        if (newCurrentCalories > VirtualPet.maxCalories)
        {
          currentCalories = VirtualPet.maxCalories;
        }
        else
        {
          currentCalories = newCurrentCalories;
        }

        trace(getName() + " ate some " + foodItem.getName() + ". It now has " + currentCalories + " calories remaining.");
      }

      // getter method AKA accesser method, from AS3.0 retriever method
      public function getHunger():Number
      {
        return currentCalories / VirtualPet.maxCalories;
      }

      public function setName (newName:String):void
      {
        if (newName.length > VirtualPet.maxNameLength)
        {
          newName = newName.substr(0, VirtualPet.maxNameLength);
        }
        else if (newName == "")
        {
          return;
        }
        petName = newName;
      }

      public function getName():String
      {
        return petName;
      }

      private function digest():void
      {
        // If digesting more calories would leave the pet's currentCalories at
        // 0 or less...
        if (currentCalories - VirtualPet.caloriesPerSecond < = 0)
        {
          // ...stop the interval from calling digest()
          clearInterval(digestIntervalID);
          // Then give the pet an empty stomach
          currentCalories = 0;
          // And report the pet's death
          trace(getName() + " has died.");
        }
        else
        {
          currentCalories -= VirtualPet.caloriesPerSecond;
          trace(getName() + " digested some food. It now has " + currentCalories + " calories remaining.");
        }
      }

      /*public function getAge()
      {
        var currentTime = new Date();
        var age = currentTime.time - this.creationTime.time;
        return age;
      }*/
    }
  }

Food.as

  // Food class
  package zoo
  {
    public class Food
    {
      private var calories:int;
      private var name:String;

      public function Food (initialCalories:int)
      {
        setCalories(initialCalories);
      }

      public function getCalories ():int
      {
        return calories;
      }

      public function setCalories (newCalories:int):void
      {
        calories = newCalories;
      }

      public function getName ():String
      {
        return name;
      }

      public function setName (newName:String):void
      {
        name = newName;
      }
    }
  }

Apple.as

  // Apple class
  package zoo
  {
    public class Apple extends Food
    {
      // Set the default number of calories for an Apple object to 100
      private static var DEFAULT_CALORIES:int = 100;
      private var wormInApple:Boolean;

      public function Apple (initialCalories:int = 0)
      {
        // If no calorie value or a negative calorie value was specified
        // for this particular object...
        if (initialCalories < = 0)
        {
          // ...use the default value
          initialCalories = Apple.DEFAULT_CALORIES;
        }

        super(initialCalories);

        wormInApple = Math.random() >= .5;

        // Set the food name for all Apple objects
        setName("Apple");
      }

      public function hasWorm ():Boolean
      {
        return wormInApple;
      }
    }
  }

Sushi.as

 // Sushi class
  package zoo
  {
    public class Sushi extends Food
    {
      private static var DEFAULT_CALORIES:int = 500;

      public function Sushi (initialCalories:int = 0)
      {
        if (initialCalories < = 0)
        {
          initialCalories = Sushi.DEFAULT_CALORIES;
        }

        super(initialCalories);

        setName("Sushi");
      }
    }
  }

Come potete vedere ogni metodo ed ogni proprietà che compone il nostro programma specifica il tipo di dato di cui fa parte ( ad esempio private var petName:String; ) o il tipo di dato che restituise ( ad esempio il metodo getName():String all'interno della classe VirtualPet ).
Quando delle classi estendono delle altre classi, come nel nostro caso Apple e Sushi estendono Food, Food si dice essere il supertype di Apple e Sushi, mentre Apple e Sushi sono il subtype di Food. Inoltre le istanze di Apple e Sushi saranno rispettivamente di tipo Apple e di tipo Sushi e contemporaneamente saranno di tipo Food mentre una istanza di Food sarà esclusivamente di tipo Food. Il tipo di dato, indicato tramite il suffisso :[tipo], si dice essere type annotation o anche type declaration.

Proprietà statiche

Una proprietà statica è una variabile che si riferisce alla classe stessa e non ad una sua istanza. Per chiarire questo concetto prendiamo ad esempio la proprietà statica maxNameLength all'interno della classe VirtualPet

private static var maxNameLength:int = 20;

Istanziando la classe VirtualPet, non vi è la necessità di differenziare il valore di maxNameLength per ogni sua singola istanza. maxNameLength, nel nostro esempio, varrà sempre 20 indistintamente. Quando una proprietà deve avere questo tipo di comportamento definiamo la variabile come static. Non sono solo le proprietà a poter essere così definite. Static può essere applicato anche a quei metodi che non richiedono l’utilizzo di proprietà istanziate.

Costanti

Le costanti sono delle variabili, statiche e non, il cui valore non cambia una volta assegnato. la sintassi per la creazione di una costante è la seguente

static const IDENTIFIER = value

Ereditarietà

L’ereditarietà tra classi è una relazione in cui la classe che estende ( tramite la parola chiave extends ) un’altra classe prende in prestito da questa il codice presente nella classe che estende. Nel nostro programma questo concetto è stato utilizzato per le classi Food con Apple e Sushi. Apple e Sushi estendono Food, quindi in Apple e Sushi saranno disponibili tutte le proprietà e i metodi dichiarati in Food. Food viene definita base class o anche ancestor mentre Apple e Sushi sono definite come derived class o anche descendants.
Moltissimo ci sarebbe da dire ancora sul concetto di ereditarietà, torneremo a parlarne.

Compilazione

Per compilare il nostro programma dovremo avere tutti i file sopre listati ( VirtualZoo.as, VirtualPet.as, Food.as, Apple.as e Sushi.as ) all’interno della directory zoo ed avere il documento flash all’interno della directory src. Per far in modo che il nostro programma visualizzi qualcosa aggiorniamo la nostra point of entry class in modo da creare un animale al suo interno e dargli da mangiare.

VirtualZoo.as

	// VirtualZoo class
  package zoo
  {
    import flash.display.Sprite;
    public class VirtualZoo extends Sprite
    {
      private var pet:VirtualPet;

      public function VirtualZoo()
      {
        pet = new VirtualPet("Stan");

        pet.eat(new Apple());  // Feed Stan an apple
        pet.eat(new Sushi());  // Feed Stan some sushi
        // Assign the pet's old name to the local variable oldName
        //var oldName = pet.getName();
        // Give the pet a new name
        //pet.setName("Marcos");
      }
    }
  }

Per compilare il programma e vedere il risultato, avendo il file flash aperto, selezioniamo la voce ‘controllo’ dal menù, quindi ‘Prova Filmato’ ( Ctrl+Invio ).

Con questo è tutto per ora, per eventuali chiarimenti vi invito a lasciare i vostri commenti

Copyright

Il codice del programma VirtualZoo è tratto dal libro “Essential ActionScript 3.0 by Colin Moock. Copyright 2007 O’Reilly Media, Inc., 0-596-52694-6”.

Related posts:

1. Personalizzare il puntatore del mouse con Actionscript 3.0 Usando la classe Custom Mouse Pointer Per le nostre applicazioni...
2. Muovere uno sprite usando la tastiera con Actionscript 3.0 Muoviamo un oggetto alla pressione dei tasti. In questo articolo...

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