Alessio Ausilio

The Xna-Way: Tutorial 15: Utente collegato ed X-Box Live pt2 L'Avatar

2011-10-11T08:00:00.000+02:00

Questa volta vi voglio parlare un poco degli Avatar degli utenti.
Come sapete è possibile creare e personalizzare il proprio Avatar, sia attraverso la console, sia attraverso il sito di X-Box live.
Voglio farvi vedere come si può, con poche righe di codice, renderizzare il proprio Avatar :)

NOTA: il codice per la gestione degli Avatar può essere fatto girare anche sotto Windows 7 (e mi pare che per i Phone, ma non avendo un tale dispositivo non ne sono sicuro), solo che in tal caso i valori ritornati dalle varie funzioni non saranno validi, e quindi non verrà renderizzato nulla.
In parole povere, GLI AVATAR SONO ESCULISA DELLA CONSOLE!

In parte riutilizzerò il codice scritto nel precedente articolo.
Nella classe del gioco aggiungiamo questi 3 campi:

   1:          AvatarDescription avatarDescription;

   2:          AvatarRenderer avatarRenderer;

   3:          AvatarAnimation avatarAnimation;

   4:          AvatarRenderer avatarRenderer2;

   5:          AvatarDescription avatarDescription2;

che rappresentano la descrizione di come è fatto il nostro Avatar (in parole povere la descrizione fisica), l'oggetto che utilizzeremo per renderizzare il nostro Avatar, l'animazione corrente che stiamo riproducendo, ed infine l'enumeratore che indica quale delle animazioni preimpostate vogliamo usare.
Gli ultimi due oggetti, avatarRender2 ed avatarDescription2, serviranno per renderizzare e contenere un Avatar creato in modo random, in modo che alla fine del nostro esempio avremo a schermo il proprio Avatar ed un altro Avatar in più.
Avremo naturalmente bisogno di mantenere i dati del giocatore attualmente loggato (rivedere articolo precedente).

Nel LoadContent del game aggiungiamo questo:

   1:              avatarDescription2 = AvatarDescription.CreateRandom(AvatarBodyType.Female);

   2:              avatarRenderer2 = new AvatarRenderer(avatarDescription2);

3:

   4:              avatarAnimation = new AvatarAnimation(preset);

Le prime due righe creano un avatar casuale (femminile) ed un renderer basato sulla descrizione dell'Avatar appena creata.
La terza riga imposta l'animazione con il preset definito come campo della classe.

Ci servirà poi un metodo per il recupero in modo asincrono dei dati dell'Avatar, che può essere il seguente:

   1:          void LoadMyAvatar(IAsyncResult result)

   2:          {

   3:              avatarDescription = AvatarDescription.EndGetFromGamer(result);

4:

   5:              if (avatarDescription.IsValid)

   6:                  avatarRenderer = new AvatarRenderer(avatarDescription);

   7:          }

Questo perchè per caricare la descrizione dell'Avatar dobbiamo chiamare il metodo AvatarDescription.BeginGetFromGamer, il quale lavora in metodo asincrono (quindi la sua esecuzione non si blocca in attesa del suo completamento) e può richiedere diverso tempo per essere completato. Quando il metodo avrò completato la sua esecuzione chiamerà il metodo da noi definito per completare le operazioni.
Per mettere tutto assieme aggiungiamo alla fine del metoto LoadContent questo:

   1:              gamer = SignedInGamer.SignedInGamers[0];

   2:              if (gamer != null)

   3:                  AvatarDescription.BeginGetFromGamer(gamer, LoadMyAvatar, null);

che non fa altro che provare a recuperare i dati del giocatore loggato, ed avvia il recupero dei dati dell'Avatar.

Nel metodo update le uniche cose da mettere sono queste:

Ci manca solo il Draw:

GraphicsDevice.Clear(Color.CornflowerBlue);

//creo la matrix per la view

Matrix view = Matrix.CreateLookAt(new Vector3(0, 0.3f, -3), new Vector3(0, 0, 0), new Vector3(0, 1, 0));

//creo la matrix per la projection

Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, GraphicsDevice.Viewport.AspectRatio, .01f, 40.0f);

if (avatarRenderer != null && gamer != null)

avatarRenderer.View = view;

avatarRenderer.Projection = projection;

avatarRenderer.World = Matrix.CreateTranslation(-1, -1, 0);

avatarRenderer.Draw(avatarAnimation.BoneTransforms, avatarAnimation.Expression);

if (avatarRenderer2 != null && avatarDescription2.IsValid)

avatarRenderer2.View = view;

avatarRenderer2.Projection = projection;

avatarRenderer2.World = Matrix.CreateTranslation(1, -1, 0);

avatarRenderer2.Draw(avatarAnimation.BoneTransforms, avatarAnimation.Expression);

spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);

if (gamer != null)

spriteBatch.DrawString(myFont, gamer.Gamertag, Vector2.Zero, Color.Black);

spriteBatch.Draw(image, new Vector2(0, 30), Color.White);

spriteBatch.DrawString(myFont, String.Format("Current Animation: {0}", preset.ToString()), new Vector2(0, 100),

Color.Black);

spriteBatch.End();

Prima creiamo la view e la projection per il render, controlliamo che il giocatore loggato, il renderer e l'animazione siano validi, e poi renderiziamo il tutto.
Poi ripetiamo anche per l'Avatar random.
Alla fine, come nel precedente articolo, si visualizza il nome della nostra gamer tag, la nostra immagine e poi si stampa il nome dell'animazione che stiamo riproducendo.

Ecco il codice completo sorgente del Game in questione:

Show∇

GraphicsDeviceManager graphics;

SpriteBatch spriteBatch;

SpriteFont myFont;

GamerServicesComponent gamerC;

SignedInGamer gamer;

Texture2D image;

InputDevice input;

AvatarDescription avatarDescription;

AvatarRenderer avatarRenderer;

AvatarAnimation avatarAnimation;

AvatarRenderer avatarRenderer2;

AvatarDescription avatarDescription2;

AvatarAnimationPreset preset = AvatarAnimationPreset.Celebrate;

public Game1()

graphics = new GraphicsDeviceManager(this);

Content.RootDirectory = "Content";

IsMouseVisible = true;

Components.Add(new BasicLibrary.Components.FPSCounter(this, false));

Components.Add((input = new InputDevice(this)));

//necessario per utilizzare la Guide

Components.Add((gamerC = new GamerServicesComponent(this)));

SignedInGamer.SignedIn += new EventHandler<SignedInEventArgs>(LoadGamer);

void LoadGamer(object sender, SignedInEventArgs e)

gamer = e.Gamer;

//recupero lo stream per l'immagine

System.IO.Stream imgIO = gamer.GetProfile().GetGamerPicture();

//creo la texture2D a partire dallo stream

image = Texture2D.FromStream(GraphicsDevice, imgIO);

AvatarDescription.BeginGetFromGamer(e.Gamer, LoadMyAvatar, null);

void LoadMyAvatar(IAsyncResult result)

avatarDescription = AvatarDescription.EndGetFromGamer(result);

if (avatarDescription.IsValid)

avatarRenderer = new AvatarRenderer(avatarDescription);

protected override void Initialize()

base.Initialize();

protected override void LoadContent()

PresentationParameters pp = GraphicsDevice.PresentationParameters;

pp.BackBufferWidth = GraphicsDevice.DisplayMode.Width;

pp.BackBufferHeight = GraphicsDevice.DisplayMode.Height;

avatarDescription2 = AvatarDescription.CreateRandom(AvatarBodyType.Female);

avatarRenderer2 = new AvatarRenderer(avatarDescription2);

spriteBatch = new SpriteBatch(GraphicsDevice);

myFont = Content.Load<SpriteFont>("font");

avatarAnimation = new AvatarAnimation(preset);

protected override void Update(GameTime gameTime)

if (input.wasPressed(Buttons.Y))

Guide.ShowSignIn(1, false);

if (gamer != null && avatarRenderer != null && avatarAnimation != null)

avatarAnimation.Update(gameTime.ElapsedGameTime, false);

if (avatarAnimation.CurrentPosition == avatarAnimation.Length)

if ((int)preset >= 30)

preset = 0;

avatarAnimation = new AvatarAnimation(++preset);

base.Update(gameTime);

protected override void Draw(GameTime gameTime)

GraphicsDevice.Clear(Color.CornflowerBlue);

//creo la matrix per la view

Matrix view = Matrix.CreateLookAt(new Vector3(0, 0.3f, -3), new Vector3(0, 0, 0), new Vector3(0, 1, 0));

//creo la matrix per la projection

Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, GraphicsDevice.Viewport.AspectRatio, .01f, 40.0f);

if (avatarRenderer != null && gamer != null)

avatarRenderer.View = view;

avatarRenderer.Projection = projection;

avatarRenderer.World = Matrix.CreateTranslation(-1, -1, 0);

avatarRenderer.Draw(avatarAnimation.BoneTransforms, avatarAnimation.Expression);

if (avatarRenderer2 != null && avatarDescription2.IsValid)

avatarRenderer2.View = view;

avatarRenderer2.Projection = projection;

avatarRenderer2.World = Matrix.CreateTranslation(1, -1, 0);

avatarRenderer2.Draw(avatarAnimation.BoneTransforms, avatarAnimation.Expression);

spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);

if (gamer != null)

spriteBatch.DrawString(myFont, gamer.Gamertag, Vector2.Zero, Color.Black);

spriteBatch.Draw(image, new Vector2(0, 30), Color.White);

spriteBatch.DrawString(myFont, String.Format("Current Animation: {0}", preset.ToString()), new Vector2(0, 100),

Color.Black);

spriteBatch.End();

base.Draw(gameTime);

HideΔ

Sinceramente pensavo che sarebbe stato molto più difficile fare una cosa del genere, invece ho trovato tutto molto ben strutturato e semplificato.
Certo non ho ancora provato ad utilizzare le animazioni personalizzate per gli Avatart, o a fare il blend tra due animazioni... Ma quelle le vedrò in futuro!

Intanto ecco a voi uno screen di quello che vedo utilizzando il mio profilo: l'Avatar sulla destra è il mio, quello sulla sinistra è quello generato casualmente!

Alla prossima :)

The Xna-Way: Tutorial 14: Utente collegato ed X-Box Live pt1 Dati di base

2011-10-10T08:00:00.000+02:00

Oggi voglio condividere alcune cose che ho provato riguardo alla gestione degli utenti XBox Live, come riconoscere se un utente ha fatto login, se ha fatto logout, chi è attualmente loggato, e le sue informazioni.

Questa sarà la prima parte di considerazioni, dovuto al fatto che alcune funzionalità sono esclusive per X-Box 360, come al gestione degli Avatar.
Riporto quindi qua solo quanto provato sotto piattaforma Windows.

Il metodo più semplice per recuperare le informazioni sull'untente attualmente collegato è tramite il seguente codice:

   1:  SignedInGamer gamer1 = Gamer.SignedInGamers[PlayerIndex.One];

Scrivendo questo, chiediamo di recuperare l'oggetto SignedInGamer relativo al giocatore che sta utilizzando il gamepad numero 1 (cosa simile si può fare con gli altri gamepad, fino all'indice 4).
Questa classe ci fornisce tutti metodi necessari per recuperare le informazioni del nostro giocatore.
Il problema però sorge quando non c'è nessuno giocatore che ha fatto log-in. In questo caso il codice precedente ci fornirà un null.
Sulla console questo si verifica quando lanciamo un gioco in modalità "anonima" possiamo dire, senza aver selezionato cioè il profilo che vogliamo usare.

Ma come possiamo fare, su pc, ad poter fare una cosa simile?
NOTA: per poter far funzionare correttamente il codice che segue, il LiveID che utilizzerete per fare log-in deve avere a disposizione un account Studente o superiore su App Hub, altrimenti andrete contro a delle spiacevoli eccezioni.

La prima cosa da fare è di aggiungere un GamerServicesComponent al nostro gioco. Possiamo farlo all'interno del costruttore del nostro Game:

   1:  Components.Add(new GamerServicesComponent(this));

Il primo passo è fatto. Ora dobbiamo far si che quando si effettua il login di un account si deve recuperare i dati, tra cui per ora ci occuperemo del nome della GamerTag e dell'immagine associata.
Aggiungiamo i seguenti campi alla nostra classe:

   1:  SignedInGamer gamer;

   2:  Texture2D image;

così facendo abbiamo definito dove andremo a memorizzare i dati recuperati.

Abbiamo bisogno di registrare un EventHandler per recuperare i dati del profilo quando viene completata la fase di login. Ecco un esempio di come può essere fatto:

   1:          void LoadGamer(object sender, SignedInEventArgs e)

   2:          {

   3:              gamer = e.Gamer;

   4:              //recupero lo stream per l'immagine

   5:              System.IO.Stream imgIO = gamer.GetProfile().GetGamerPicture();

   6:              //creo la texture2D a partire dallo stream

   7:              image = Texture2D.FromStream(GraphicsDevice, imgIO);

   8:          }

mentre nel costruttore, dopo la creazione del GamerServicesComponent, andiamo a registrare il nostro handler come segue:

   1:  SignedInGamer.SignedIn += new EventHandler<SignedInEventArgs>(LoadGamer);

Il nostro metodo Draw sarà semplicissimo!

   1:          protected override void Draw(GameTime gameTime)

   2:          {

   3:              GraphicsDevice.Clear(Color.CornflowerBlue);

4:

   5:              spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);

   6:              if (gamer != null)

   7:              {

   8:                  spriteBatch.DrawString(myFont, gamer.Gamertag, Vector2.Zero, Color.Black);

   9:                  spriteBatch.Draw(image, new Vector2(0,30), Color.White);

  10:              }

  11:              spriteBatch.End();

12:

  13:              base.Draw(gameTime);

  14:          }

Ok vediamo di riassumere: creiamo il nostro EventHandler, il quale serve a recuperare i dati del Gamer che fa login (quindi la GamerTag, la sua immagine, i suoi Ack, la lista dei suoi amici, etc). Questo Handler viene chiamato quando il login viene completato con successo. E dopo di questo verrano visualizzate dal metodo Draw il nome della GamerTag e la sua immagine.

Ecco ora a voi alcuni screenshot! (sono relativi alla versione che ho fatto girare sotto Windows 7, quindi sulla console potrebbero essere "leggermente" differenti)
Una volta fatto partire il gioco premete il tastone centrale del vostro pad (o il tasto Home sulla tastiera). E quello che vedrete sarà più o meno questo:

Dopo che avrete accettato le condizioni d'uso, andate su "Accedi", dove avrete una schermata come la seguente:

Inserite i dati del vostro LiveID (che vi ricordo deve disporre di un account Studente o superiore su Abb Hup per essere provato con successo da chi scrive il codice), e avrete che inizierà la procedura di login (io ho anche spuntato l'opzione per fare in modo che ogni volta effettui l'accesso in automatico).

Quando il login sarà completo vi verrà notificato con un messaggio!
Se fate come me, e avete messo il login automatico dell'account (in modo da non dover rifare la procedura a mano ogni volta), se riavviate l'applicazione ed aspettate qualche secondo, ecco cosa vedrete (salvo GamerTag diversa XD):

Ora le basi ci sono! Potete sbizzarrirvi!

Spero di esservi stato utile!
A presto :)

The Xna-Way: Tutorial 13: Semplice gestore audio

2011-09-30T14:40:00.001+02:00

Oggi voglio proporvi una componente per gestire gli effetti sonori e le musiche del nostro gioco.
Perchè diciamocelo, un gioco muto non ha proprio un bell'aspetto ed è anche poco accattivamente.

Quello che mi propongo è di mostrarvi un componente che si occupi di caricare gli effetti sonori e le canzoni che vogliamo utilizzare nel nostro progetto, per poi poterle richiamare ed utilizzare a nostro piacimento da qualsiasi punto del nostro progetto (a patto di poter accedere e riferire l'interfaccia definita per interagire con il nostro componente).

Come prima cosa definiamoci l'interfaccia da utilizzare con il nostro audioManager:

Show∇

Molto intuitivamente diamo così la possibilità di agire sul volume dei suoni e delle musiche, permettiamo di caricare un singolo suono/canzone specificando anche l'ID da assegnargli, e che sarà utilizzato per recuperarlo e riprodurlo. Definiamo poi quei metodi che serviranno per riprodurre/fermare/riprendere una cazone e per riprodurre e fermare i suoni.
Qualcuno mi potrà criticare il fatto che utilizzo degli anonimi e diffcili ID di tipo long per identifcare i suoni e le canzoni e non un nome. Io ragiono sul fatto che molto probabilmente la lista dei file audio da gestire mi arriverà da un qualche editor, che avrò usato per definire la lista di tutti i miei asset. Tali asset saranno riferiti da ogni luogo tramite i loro identificativi numeri, questo perchè il nome può essere cambiato per varie ragioni (preferenze, cambio di idee, diversa classificazione, etc) mentre un ID numerico rimarrà presumibilmente (a meno di persone poco sagge che vanno a mettere le manine nutellose dove non dovrebbero) lo stesso per tutto il tempo.
Oltre al fatto che un numero occupa molto meno spazio di un stringa ^__^

Continuiamo però nella nostra esposizione: dobbiamo ora implementare il tutto.

Show∇

   1:  /// <summary>

   2:  /// Gestisce la musica di sottofondo ed i suoni che vengono riprodotti

   3:  /// </summary>

   4:  public class AudioManager : GameComponent, AudioManagerI

   5:  {

   6:      #region Private fields

   7:      private ContentManager content;

   8:      public ContentManager ContentManager { get { return content; } }

9:

  10:      //lista delle canzoni che vogliamo gestire

  11:      private Dictionary<long, Song> songs = new Dictionary<long, Song>();

  12:      //lista dei suoni che vogliamo gestire

  13:      private Dictionary<long, SoundEffect> sounds = new Dictionary<long, SoundEffect>();

14:

  15:      //canzone corrente che stiamo riproducendo

  16:      private Song currentSong = null;

  17:      //lista dei suoni che stiamo correntemente riproducendo

  18:      private List<SoundEffectInstance> playingSounds;

19:

  20:      //sono in pausa?

  21:      private bool isMusicPaused = false;

  22:      #endregion

23:

  24:      /// <summary>

  25:      /// ID della canzone correntemente riprodotta

  26:      /// </summary>

  27:      public long Current_IDSong { get; private set; }

28:

  29:      /// <summary>

  30:      /// Volume delle canzoni

  31:      /// </summary>

  32:      public float MusicVolume

  33:      {

  34:          get { return MediaPlayer.Volume; }

  35:          set { MediaPlayer.Volume = value; }

  36:      }

37:

  38:      /// <summary>

  39:      /// Volume per i suoni

  40:      /// </summary>

  41:      public float SoundVolume

  42:      {

  43:          get { return SoundEffect.MasterVolume; }

  44:          set { SoundEffect.MasterVolume = value; }

  45:      }

46:

  47:      /// <summary>

  48:      /// True se la canzone corrente è in esecuzione o in pausa (!= stopped)

  49:      /// </summary>

  50:      public bool IsSongActive { get { return currentSong != null && MediaPlayer.State != MediaState.Stopped; } }

51:

  52:      /// <summary>

  53:      /// True se la canzone corrente è in pausa

  54:      /// </summary>

  55:      public bool IsSongPaused { get { return currentSong != null && isMusicPaused; } }

56:

  57:      public AudioManager(Game game)

  58:          : this(game, "Content")

  59:      {

  60:      }

61:

  62:      public AudioManager(Game game, string contentFolder)

  63:          : base(game)

  64:      {

  65:          Game.Services.AddService(typeof(AudioManagerI), this);

  66:          Current_IDSong = -1;

  67:          content = new ContentManager(game.Content.ServiceProvider, contentFolder);

  68:          playingSounds = new List<SoundEffectInstance>();

  69:      }

70:

  71:      /// <summary>

  72:      /// Carica una canzone.

  73:      /// </summary>

  74:      /// <param name="songID">Id da assegnare alla canzone da caricare</param>

  75:      /// <param name="songName">Nome della canzone da caricare</param>

  76:      public void LoadSong(long songID, string songName)

  77:      {

  78:          songs.Add(songID, content.Load<Song>(songName));

  79:      }

80:

  81:      /// <summary>

  82:      /// Carica un suono.

  83:      /// </summary>

  84:      /// <param name="sounID">Id da assegare al suono da caricare</param>

  85:      /// <param name="soundName">Nome del suono da caricare</param>

  86:      public void LoadSound(long soundID, string soundName)

  87:      {

  88:          sounds.Add(soundID, content.Load<SoundEffect>(soundName));

  89:      }

90:

  91:      /// <summary>

  92:      /// Libera la memoria da tutte le canzoni e suoni caricati

  93:      /// </summary>

  94:      public void UnloadContent()

  95:      {

  96:          content.Unload();

  97:      }

98:

  99:      /// <summary>

 100:      /// Riproduce la canzone con id passato

 101:      /// </summary>

 102:      /// <param name="idSong">Id della canzone da riprodurre</param>

 103:      public void PlaySong(long idSong)

 104:      {

 105:          //controllo che la canzone che voglio riprodurre non sia quella che sto correntemente riproducendo

 106:          if (Current_IDSong != idSong)

 107:          {

 108:              if (currentSong != null) //fermo quella attuale

 109:              {

 110:                  MediaPlayer.Stop();

 111:              }

 112:

 113:              if (songs.TryGetValue(idSong, out currentSong))

 114:              {

 115:                  Current_IDSong = idSong; //aggiorno

 116:

 117:                  isMusicPaused = false;

 118:                  MediaPlayer.IsRepeating = true; //metto in loop

 119:                  MediaPlayer.Play(currentSong); //riproduco

 120:

 121:                  if (!Enabled)

 122:                  {

 123:                      MediaPlayer.Pause();

 124:                  }

 125:              }

 126:          }

 127:      }

 128:

 129:      /// <summary>

 130:      /// Mette in pausa la canzone corrente

 131:      /// </summary>

 132:      public void PauseSong()

 133:      {

 134:          if (currentSong != null && !isMusicPaused)

 135:          {

 136:              if (Enabled) MediaPlayer.Pause();

 137:              isMusicPaused = true;

 138:          }

 139:      }

 140:

 141:      /// <summary>

 142:      /// Fa ripartire la canzone corrente

 143:      /// </summary>

 144:      public void ResumeSong()

 145:      {

 146:          if (currentSong != null && isMusicPaused)

 147:          {

 148:              if (Enabled) MediaPlayer.Resume();

 149:              isMusicPaused = false;

 150:          }

 151:      }

 152:

 153:      /// <summary>

 154:      /// Ferma la cazone corrente

 155:      /// </summary>

 156:      public void StopSong()

 157:      {

 158:          if (currentSong != null && MediaPlayer.State != MediaState.Stopped)

 159:          {

 160:              MediaPlayer.Stop();

 161:              isMusicPaused = false;

 162:          }

 163:      }

 164:

 165:      /// <summary>

 166:      /// Riproduce il suono con id passato

 167:      /// </summary>

 168:      /// <param name="soundId">Id del suono da riprodurre</param>

 169:      public void PlaySound(long soundId)

 170:      {

 171:          SoundEffect sound;

 172:

 173:          if (!sounds.TryGetValue(soundId, out sound))

 174:          {

 175:              throw new ArgumentException(string.Format("Sound '{0}' not found", soundId));

 176:          }

 177:

 178:          playingSounds.Add(sound.CreateInstance());

 179:          int index = playingSounds.Count - 1;

 180:

 181:          playingSounds[index].Volume = SoundVolume;

 182:          playingSounds[index].Pitch = 0.0f;

 183:          playingSounds[index].Pan = 0.0f;

 184:          playingSounds[index].Play();

 185:

 186:          if (!Enabled)

 187:          {

 188:              playingSounds[index].Pause();

 189:          }

 190:      }

 191:

 192:      /// <summary>

 193:      /// Fermat tutti i suoni correntemente riprodotti

 194:      /// </summary>

 195:      public void StopAllSounds()

 196:      {

 197:          for (int i = 0; i < playingSounds.Count; ++i)

 198:          {

 199:              playingSounds[i].Stop();

 200:              playingSounds[i].Dispose();

 201:          }

 202:          playingSounds.Clear();

 203:      }

 204:

 205:      public override void Update(GameTime gameTime)

 206:      {

 207:          for (int i = playingSounds.Count - 1; i >= 0; i--)

 208:          {

 209:              //rimuove i suoni che sono stati completati

 210:              if (playingSounds[i] != null && playingSounds[i].State == SoundState.Stopped)

 211:              {

 212:                  playingSounds[i].Dispose(); //libero la memoria

 213:                  playingSounds.RemoveAt(i);

 214:              }

 215:          }

 216:

 217:          //se ho finito di riprodurre la canzone corrente stop

 218:          if (currentSong != null && MediaPlayer.State == MediaState.Stopped)

 219:          {

 220:              currentSong = null;

 221:              Current_IDSong = -1;

 222:              isMusicPaused = false;

 223:          }

 224:

 225:          base.Update(gameTime);

 226:      }

 227:

 228:      // Mette in pausa tutto se sospeso, altrimenti riprende tutto

 229:      protected override void OnEnabledChanged(object sender, EventArgs args)

 230:      {

 231:          if (Enabled)

 232:          {

 233:              for (int i = 0; i < playingSounds.Count; i++)

 234:              {

 235:                  if (playingSounds[i] != null && playingSounds[i].State == SoundState.Paused)

 236:                  {

 237:                      playingSounds[i].Resume();

 238:                  }

 239:              }

 240:

 241:              if (!isMusicPaused)

 242:              {

 243:                  MediaPlayer.Resume();

 244:              }

 245:          }

 246:          else

 247:          {

 248:              for (int i = 0; i < playingSounds.Count; i++)

 249:              {

 250:                  if (playingSounds[i] != null && playingSounds[i].State == SoundState.Playing)

 251:                  {

 252:                      playingSounds[i].Pause();

 253:                  }

 254:              }

 255:

 256:              MediaPlayer.Pause();

 257:          }

 258:

 259:          base.OnEnabledChanged(sender, args);

 260:      }

 261:  }

HideΔ

Il codice mi pare che sia abbastanza autoesplicativo, se necessita di commenti non esitate a chiedermeli per email o nei commenti.
Solo una minima spiegazione: un SoundEffect rappresenta una singola risorsa sonora caricata, ed è possibile riprodurla utilizzando il metodo play fornito da tale classe.
Abbiamo invece che la SoundEffectInstance rappresenta una singola istanza di una risorsa sonora in fase di riproduzione (o sospesa o fermata). Questo vuol dire che con le SoundEffectInstance possiamo riprodurre più copie del nostro suono tranquillamente. Da fare attenzione al fatto che possiamo creare molte instance da un singolo SoundEffect, e nel caso liberiamo la memoria di quest'ultimo per poi provare a riprodurre una istanza ottenuta da questo... bè gli effetti saranno non piacevoli! Eccezioni su eccezioni!

Forse c'è un punto che può essere in dubbio: come faccio a sapere che tutti i suoni che riproduco verrano riprodotti?
Oppure possiamo mettere la questione nel senso di "quale è il numero massimo di suoni che posso riprodurre sulla mia console?"
Come potete leggere a questa pagine di MSDN abbiamo che

On Zune, a game can have a maximum of 16 total playing SoundEffectInstance instances at one time, combined across all loaded SoundEffect objects. The only limit to the total number of loaded SoundEffectInstance and SoundEffect objects is available memory. However, the user can play only 16 sound effects at one time. Attempts to play a SoundEffectInstance beyond this limit will fail. On Windows, there is no hard limit. Playing too many instances can lead to performance degradation. On Xbox 360, the limit is 300 sound effect instances loaded or playing. Dispose of old instances if you need more.

quindi credo che 300 suoni contemporaneamente siano sufficienti per i nostri scopi.

Spero di esservi stato un minimo utile.

Se volete vedere un esempio più complesso di gestore audio, con una personalizzazione migliore di quello che potete fare, vi rimando alla XnaWiki. Il loro esempio è quello a cui mi sono ispirato per creare il mio personale AudioManager, solo che come ho detto, non mi piacevano alcune cose riguardo all'identificazione degli asset, oltre al fatto che il numero dei suoni riproducibili tutti assieme era limitato a livello di codice.

A presto!

The Xna-Way: Tutorial 12: Performance & Ottimizzazioni pt1

2011-07-31T17:33:00.001+02:00

Vediamod i fare il punto su qualche considerazione che ho fatto relativamente allo sviluppo e deploy su PC vs quello su Xbox 360.

Da quello che ricordo, nonostante si possa far girare i progetti XNA sia su pc che su console, i frameword utilizzati per far girare gli applicativi sono simili ma diversi sotto alcuni aspetti fondamentali. Primo tra tutti la gestione del garbage collector.

Su PC viene fatto girare il .NET framework completo, mentre sulla console viene utilizzato quello che si chiama .NET Compact Framework (che dovrebbe essere tra l'altro utilizzato anche per alcuni dispositivi portatili sempre di proprietà della Microsoft).

Tale Compact Framework è alla fin fine un sottoinsieme di quello che gira su PC, ma questo implica che le funzioni che mette a disposizione sono minori.
Per quanto riguarda il Garbage Collector, il compact framework ha una versione che possiamo vedere come meno potente.
Con il Compact Framework si è costretti a controllare ogni oggetto presente in memoria per vedere se è ancora necessario o meno. Quindi attenzione all'allocazione di tanti oggetti e di oggeti di grosse dimenzioni.

Altro problema è il filtraggio degli oggetti di una collezione secondo una certa condizione.
Per un esempio: in una prova dovevo renderizzare gli oggetti che rientravano nella zona della vista del livello, e per fare questo nella versione WINDOWS del gioco avevo utilizzato il metodo Where di Enumerator, defidendomi delle lambda expression per definire il filtro. Sotto Windows funzionava tutto abbastanza bene.
Ma non appena ho eseguito il tutto sulla console le prestazioni sono precipitate vertiginosamente.
A quanto pare i metodi offerti da Enumerator, che accettano delle lambda expression, creano delle nuove liste/oggetti ogni volta che vengono invocati, e questo porta via tante risorse all'esecuzione.
Come risolvere e quindi ottimizzare il codice XNA?
Per risolvere il calo di prestazioni ho provato con il un classico for/foreach con un semplice if-then per l'esecuzione del codice. Ed il guadagno in frame per secondo è stato notevole (per farvi un esempio numerico: dai 26 fps che ottenevo inizialmente sono arrivato a 170 circa!).
Un'altra prova che ho fatto è stata con le query definite tramite LinQ. Il vantaggio di queste query è che permettono di esprimere in modo facile e naturale espressioni di filtraggio come se si scrivesse una query per un database relazionale.
La lettura di tale query è decisamente più semplice di un if-then-else che occupa diverse righe.
E per le prestazioni direte voi?
Da quello che ho visto (sempre con i dati numerici che ho riportato prima) da 170 fps sulla console sono sceso a circa 165.
5 fps per una maggiore leggibilità e manutenzione del codice... Accettabile secondo voi? Per ora secondo me si. Ma in caso si abbia bisogno di prestazioni estreme, e dove anche un solo fps guadagnato è un successo armatevi di calma e scrivetevi le vostre belle condizioni a manina!

Da considerare perè che fino a quando il vostro progetto gira oltre i 60 fps potete stare tranquilli e occuparvi poco delle ottimizzazioni in generale. Il problema è quando scendete sotto i 60... 60 fps è la vostra line della morte.

Ok...
queste sono solo delle mie considerazioni, dovute a prove che ho fatto e a qualche pagina di libro che ho letto.
In caso abbia sbagliato qualcosa siete pregati di farmelo notare.

A presto.
Odino

The Xna-Way: Special Tutorial: DreamSpark! Develop and deploy on the xBox 360

2011-07-23T10:10:00.000+02:00

Finalmente in questi giorni sono riuscito a decidermi a comprare una xBox 360.
Si sono stanto tanto stronzo che per tutti questi anni ho sviluppato con XNA solo su pc.

Ma ora adesso che avevo la mia adorata console (piccolo momento di gloria: la slim è una cosa fantastica ^__^) dovevo trovare il modo di svilupparci sopra in modo appropriato.

Il problema principale stava nel fatto che non avevo ora come ora la possibilithttp://www.blogger.com/img/blank.gifà di pagare l'abbonamento annuale di 75€ per l'XNA creator club. E sul sito MSDNAA della mia università non c'era nemmeno più la possibilità di richiedere l'abbonamento studenti.

Ma per fortuna il WEB ci viene in aiuto. Può darsi che queste info siano ugualmente recuperabili da altre parti sul web, ma ho deciso lo stesso di condividerle tramite questo blog.

La Microsoft ha messo a disposizione di tutti gli studenti DEL MONDO (o perlomeno di moltissimi paesi) la possiblità di usufruire di molti http://www.blogger.com/img/blank.gifsuoi prodotti (certificati) in modo gratuito o scontato.
Il segreto di tutto questo è il progetto DreamSpark, a cui potete accedere tramite www.dreamspark.com.

Non voglio stare a farla tanto lunga: in parole povere questo permette a tutti gli stundenti universitari di qualsiasi facoltà (basta che sia registrata negli elenchi della Microsoft) di accedere ai loro prodotti.

Ma vediamo come utilizzare tutto ciò per ottenere un account studente di 12 mesi per Xna creator Club (oramai di dovrebbe dire App Hub O_O).

Come presequisito è necessario essere studenti iscritti ad una qualche facoltà italiana!
La prima cosa da fare è accedere con il vostro LiveID (MI RACCOMANDO! DOVETE ACCEDERE CON IL LiveID A CUI E' COLLEGATA LA GAMERTAG CHE UTILIZZATE SULLA VOSTRA CONSOLE!) ed andare qua https://users.create.msdn.com/Register/ e selezionare la voce Student quando vi verrà richiesto.
Premendo next, al prossimo passo vi verrrà richiesta la certificazione tramite DreamSpark. Naturalmente si parte dal presesupposto che voi non l'abbiate, e quindi dovrete premere su Visit DreamSpark now to get verified.
Fatto ciò verrete reindirizzati al sito di DreamSpark, il quale vi chiederà di inserire alcuni dati fondamentali.
Step1
Vi chiederà di inserire il paese in cui risiedete, poi selezionate Verify as a Student, e nell'ultima voce Get Verified through my School

Step2
Selezionate la vostra università nell'elenco di quelle disponibili per il vostro paese (se non è presente allora è un bel problema... ma non credo che ci dovrebbero essere atenei italiani mancanti).

Step3
Adesso dovete inserire la vostra mail da studente, quella data dal vostro dipartimento per intenderci. A questa mail sarà inviata una mail con il codice per poter completare la verifica su DreamSpark.
Voi potreste chiedere "Chi mi vieta di inserire una mail diversa?". Io non ho provato... ma non credo che sia molto complicato verificare al volo se la mail che inserite viene gestita dei server dell'università che avete scelto.
Quindi è bene inserire il vostro vero indirizzo e-mail di dipartimento.

Step4
Andate a leggere la mail che vi è arrivata. All'interno troverete il codice ed il link da visitare (dove appunto vi verrà richiesto di inserire il codice) per completare la registrazione.

Step5
Ok ora siete verificati su DreamSpark!
Tornate alla registrazione su App Hub, ripetere la procedura vista prima, selezionando sempre Student. Solo che questa volta mamma Microsoft si http://www.blogger.com/img/blank.gifaccorgerà della registrazione a DreamSpark e vi farà procedere.
Ora non dovete far altro che seguire tutti i passi, riempire tutti i campi (NOTA: le info che inserite du App Hub devono essere coerenti con quelle inserite sulla vostra gamerTag, se no il sistema si altera e vi chiede di modificare i dati), ed alla fine avrete il vostro account!

Nota: per chi vuole anche delle immagini sono riuscito a trovare proprio ora questo topic!
Guida alla verifica su DreamSpark.

Ora non dovete far altro che accendere la vostra console, accedere con la gamerTag relativa all'indirizzo/LiveID con cui vi siete registrati su App Hub.
Nel market place, sotto la lettera X, troverete l'XNA Game Studio Connect (NOTA: il programmino è scaricabile anche da chi non si è registrato ad App Hub, solo che se l'account non soddisfa il tipo di registrazione il programma non parte -.-).

Ora non ci resta che collegare la nostra console al pc.
Per fare questo dobbiamo fare alcuni altri passi.
Connect xBox Step1
Dovete lanciare Xna Game Studio Connect. Quando sarà partito vedrete a schermo un codice. Segnatevelo da qualche parte perchè vi servirà.

Connect xBox Step2
Dal vostro pc dovete andare nel menù Tutti i programmi/Microsoft Xna Game Studio 4.0/ e selezionare la voce XNA Game Studio Device Center.
Qua dovrete selezionare la vostra console, dargli un nome, e quando richiesto inserire il codice che vi siete segnati prima.

Ok tutto fatto!
Pc e console sono collegati.
Per provare qualcosa adesso dovete fare quando segue:
con Xna Game Studio Connect attivo sulla console ed in attesa di connessione dal vostro pc, dovete aprire Visual Studio (o Visual C#), aprire un progetto Xna (di tipo xBox360) e lanciarlo.
Il progetto verrà compilato e distribuito sulla console in automatico. E potrete provarlo direttamente li!

Tanto per gradire: funziona anche il debug! Cioè potete mettere dei break point nel codice, e l'esecuzione del gioco sulla console si bloccherà al raggiungimento del break point. :))
Certo non potrete modificare al volo il codice come si fa in locale, ma una cosa pur sempre utile.

Spero di essere stato il più possibile chiaro.
In seguito pubblicherò altri articoli sulle prove e sulle performance ottenute eseguendo vari progetti sulla console.

Per ogni chiarimento chiedete pure tramite mail o tramite commenti.
Saluti a tutti!
Odino

The Xna-Way: Tutorial 11: Spippolando con il gamePad

2011-07-09T19:30:00.001+02:00

Ho recentemenete acquistato tramite Amazon.it il gamepad della xbox 360 con cavo usb, in modo da poterlo utilizzare su pc, e da poter provare direttamente su di esso le funzionalità del pad, che altrimenti sarebbero disponibili solo sulla console.

Ho cominciato a giocarci, e questo è quanto ne ho ricavato fino ad ora.

Il pad in se per se è un ottimo prodotto. Ma questo già si sapeva :)

Xna mette a dispozizione il GamePadState per poter interrogare lo stato del nostro pad. Come per tastiera e mouse, possiamo recuperare lo stato corrente del nostro pad tramite il metodo GamePad.GetState(PlayerIndex), dove PlayerIndex indica il numero del giocatore/pad di cui vogliamo lo stato (il giocatore è identificato sul pad dal let acceso attorno al pulsante centrale, ed il valore di PlayerIndex varia tra 1 e 4).

Tra i valori ed i metodi messi a disposizione da tale oggetto possiamo mettere in evidenza:
ThumbStick: ha due proprietà, Left e Right, che permettono di sapere la posizione dei due stick analogici del pad.
Left e Right sono dei Vector2, quindi a loro volta hanno i valori per X ed Y. I valori che possono assumere variano in [-1,+1] (estremi compresi), dove -1 significa che lo stick è completamente a sinistra/basso, 1 significa che lo stick è completamente a destra/alto. Lo 0 significa che lo stick non è stato mosso. Valori intermedi rappresentano posizione intermedie dello stick nelle varie direzioni.

Triggers: i due grilletti posteriori del pad, oltre che come dei semplici bottoni (LeftTrigger e RightTrigger) che hanno stato rilasciato/premuto, possono essere identificati tramite questa proprietà, che contiene a sua volta due valori Left e Right, di tipo float. Questi due valori, varianti tra [0,1], estremi compresi, mi dicono quanto il grilletto è premuto, con 0 = rilasciato, 1 = completamente premuto, e valori intermedi, come prima, identificano posizioni intermedie.

Dpad: identifica lo stato delle "frecce direzionali" del pad. Le direzioni possibili sono 4, ma possono essere combinate due a due. Tramite questo oggetto possiamo controllare quali delle direzioni sono premute.
Notate che il Dpad è completamente diverso dallo stick sinistro, quindi quando muovete lo stick sinistro non cambiate in nessun modo lo stato del Dpad (come era stato portato a credere inizialmente -.-), e viceversa.

Spero che queste poche e brevi considerazioni personali sull'uso del gamepad possano tornare utili a qualcuno. Se avrò altro da aggiungere aggiornerò il post.

A presto.
Odino

The Xna-Way: Tutorial 10: Sprite Sheet & 2D Animation

2011-04-16T22:37:00.006+02:00

Vi siete mai imbattuti, mentre ricercavate risorse grafiche per i vostri giochi, negli sprite sheet? Immagini contenenti frame delle animazioni di personaggi, effetti speciali o altro?
(Nota: molto belli sono quelli rippati dai vecchi giochi per il SNES, che potete trovare su alcuni siti, i cui link metterò alla fine del post).

Vediamo un piccolo esempio su come possono essere utilizzati.

Il codice sarà allegato alla fine del post!
La strutturazione del codice per come l'ho pensata io è la seguente:
- TextureCollection: un catalogo contenente tutte le texture2D caricate nel gioco, accedibili tramite un id unico
- SpriteSheetCollection: un catalogo contenente gli SpriteSheet definiti per il gioco, anche questi accedibili tramite un id unico
- AnimationDescCollection: un catalogo contenente la descrizione delle animazioni definite per il gioco, anche queste accedibili trami un id unico

Le collezioni sopra definite sono definite come statiche, in modo che possano essere accedibili da ogni parte del codice.

VI sono poi altre classi:
- SpriteSheet: rappresenta un'immagine divisa in frame. Contiene l'identificatore della texture all'interno della TextureCollection, il numero di frame sull'asse X e sull'asse Y, oltre che un metodo per calcolare il rettangolo relativo al frammento di immagine che si vuole utilizzare.

-AnimationDesc: contiene una collezione di frame che specificano l'animazione, oltre a dire se l'animazione deve essere ripetuta all'infinito o meno.
- Frame: speficifica quale SpriteSheet utilizzare e quale è l'id del frammento da utilizzare (NOTA: I frammenti contentuni all'interno di uno spriteSheet sono numerati da 0 al numero massimo -1, partendo dall'angolo in alto a sinistra e procedendo da destra verso sinistra, e dall'alto verso il basso).

- Animation: è l'oggetto che implementa l'animazione vera e propria. Contiene l'id della descrizione dell'animazione che si sta utilizzando, il frame corrente (cioè dove siamo arrivati a riprodurre l'animazione), il tempo passato dall'ultimo aggiornamento (in modo da poter avanzare il frame corrente al momento giusto), e la posizione dell'animazione nella vista del gioco.

Infine arriviamo al componente principale:
- AnimationManager: è il gameComponent che si preoccupa di gestire ed animare gli oggetti Animation che gli vengono dati in pasto.

Ecco il codice per le classi principali:

Show∇

   1:      /// <summary>

   2:      /// rappresenta un singolo frame dell'animazione

   3:      /// Si caratterizza per l'id dello spriteSheet e per il frammento di immagine utilizzato dal frame

   4:      /// </summary>

   5:      public class Frame

   6:      {

   7:          /// <summary>

   8:          /// Id dello spriteSheet che deve essere presente nella spriteSheetCollection

   9:          /// </summary>

  10:          public long IdSpriteSheet { get; private set; }

  11:          /// <summary>

  12:          /// Id del frammento dell'immagine che si utilizza per il particolare frame

  13:          /// </summary>

  14:          public int IdFragment { get; private set; }

15:

  16:          /// <summary>

  17:          /// Costruisce un frame per l'animazione

  18:          /// </summary>

  19:          /// <param name="idSpriteSheet">Id di riferimento per lo spriteSheet che deve essere presente nella spriteSheetCollection</param>

  20:          /// <param name="idFragment">Id del frammento dell'immagine che si utilizza per il particolare frame</param>

  21:          public Frame(long idSpriteSheet, int idFragment)

  22:          {

  23:              this.IdSpriteSheet = idSpriteSheet;

  24:              this.IdFragment = idFragment;

  25:          }

  26:      }

27:

  28:      /// <summary>

  29:      /// Descrive come è fatta un'animazione

  30:      /// </summary>

  31:      public class AnimationDesc

  32:      {

  33:          /// <summary>

  34:          /// Lista dei frame che compongono l'animazione

  35:          /// </summary>

  36:          public List<Frame> FrameList { get; set; }

37:

  38:          /// <summary>

  39:          /// Vale true se l'animazione deve ripetersi

  40:          /// False altrimenti

  41:          /// </summary>

  42:          public bool Loop { get; set; }

43:

  44:          /// <summary>

  45:          /// Crea la descrizione di un'animazione che non si ripete dopo la fine

  46:          /// </summary>

  47:          public AnimationDesc()

  48:              : this(false)

  49:          {

  50:          }

51:

  52:          /// <summary>

  53:          /// Crea la descrizione di un'animazione permettendo di configurare la ripetizione

  54:          /// </summary>

  55:          /// <param name="loop">True se si vuol far ripetere l'animazione, false altrimenti</param>

  56:          public AnimationDesc(bool loop)

  57:          {

  58:              FrameList = new List<Frame>();

  59:              Loop = loop;

  60:          }

  61:      }

62:

  63:      /// <summary>

  64:      /// Definisce un'animazione da visualizzare a schermo dall'AnimationManager

  65:      /// </summary>

  66:      public class Animation

  67:      {

  68:          /// <summary>

  69:          /// Posizione (nel range dello schermo) in cui viene visualizzata l'animazione

  70:          /// </summary>

  71:          public Vector2 Position { get; set; }

72:

  73:          /// <summary>

  74:          /// Frame corrente dell'animazione

  75:          /// </summary>

  76:          public int CurrentFrame { get; set; }

77:

  78:          /// <summary>

  79:          /// Id dell'AnimationDesc utilizzata

  80:          /// </summary>

  81:          public long IdAnimationDesc { get; private set; }

82:

  83:          /// <summary>

  84:          /// Tempo passato dall'ultimo cambio di frame

  85:          /// </summary>

  86:          public int ElapsedTime { get; set; }

87:

  88:          /// <summary>

  89:          /// Crea una nuova Animazione con riferimento all'AnimationDesc con id passato. Creata in posizione (0,0)

  90:          /// </summary>

  91:          /// <param name="idAnimation">Id dell'AnimationDesc presente nella AnimationsDescCollection</param>

  92:          public Animation(long idAnimationDesc)

  93:              : this(idAnimationDesc, Vector2.Zero)

  94:          {

  95:          }

96:

  97:          /// <summary>

  98:          /// Crea una nuova Animazione con riferimento all'AnimationDesc con id passato.

  99:          /// </summary>

 100:          /// <param name="idAnimation">Id dell'AnimationDesc presente nella AnimationsDescCollection</param>

 101:          /// <param name="position">Posizione dell'Animazione</param>

 102:          public Animation(long idAnimationDesc, Vector2 position)

 103:          {

 104:              this.IdAnimationDesc = idAnimationDesc;

 105:              this.Position = position;

 106:              ElapsedTime = 0;

 107:          }

 108:      }

 109:

 110:      /// <summary>

 111:      /// Component per il rendering della Animation a schermo

 112:      /// </summary>

 113:      public class AnimationManager : Microsoft.Xna.Framework.DrawableGameComponent

 114:      {

 115:          //spritebatch su cui disegnare

 116:          SpriteBatch spriteBatch = null;

 117:

 118:          /// <summary>

 119:          /// lista delle animazioni da eseguire. Un'animazione viene automaticamente rimossa al termine della sua animazione

 120:          /// </summary>

 121:          public List<Animation> AnimationList { get; set; }

 122:

 123:          public AnimationManager(Game game)

 124:              : base(game)

 125:          {

 126:              AnimationList = new List<Animation>();

 127:          }

 128:

 129:

 130:          protected override void LoadContent()

 131:          {

 132:              spriteBatch = new SpriteBatch(Game.GraphicsDevice);

 133:              base.LoadContent();

 134:          }

 135:

 136:          public override void Initialize()

 137:          {

 138:              base.Initialize();

 139:          }

 140:

 141:          public override void Update(GameTime gameTime)

 142:          {

 143:              int delta = gameTime.ElapsedGameTime.Milliseconds;

 144:

 145:              AnimationDesc desc = null;

 146:              for (int i = AnimationList.Count - 1; i >= 0; i--)

 147:              {

 148:                  desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc];

 149:                  if (!desc.Loop && AnimationList[i].CurrentFrame == desc.FrameList.Count - 1)

 150:                      AnimationList.RemoveAt(i);

 151:                  else if (desc.Loop && AnimationList[i].CurrentFrame == desc.FrameList.Count - 1)

 152:                      AnimationList[i].CurrentFrame = 0;

 153:              }

 154:

 155:              for (int i = 0; i < AnimationList.Count; i++)

 156:              {

 157:                  desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc];

 158:                  AnimationList[i].ElapsedTime += delta;

 159:                  if (AnimationList[i].ElapsedTime >= 40)

 160:                  {

 161:                      AnimationList[i].ElapsedTime -= 40;

 162:                      AnimationList[i].CurrentFrame++;

 163:                  }

 164:              }

 165:

 166:              base.Update(gameTime);

 167:          }

 168:

 169:          public override void  Draw(GameTime gameTime)

 170:          {

 171:              spriteBatch.Begin(SpriteSortMode.BackToFront, BlendState.AlphaBlend);

 172:              AnimationDesc desc = null;

 173:              for (int i = 0; i < AnimationList.Count; i++)

 174:              {

 175:                  desc = AnimationsDescCollection.AnimationCollection[AnimationList[i].IdAnimationDesc];

 176:                  Frame current = desc.FrameList[AnimationList[i].CurrentFrame];

 177:                  SpriteSheet spriteSheet = SpriteSheetCollection.SpritesSheetCollection[current.IdSpriteSheet];

 178:

 179:                  Texture2D img = TextColl.TextureCollection[spriteSheet.IdTexture];

 180:                  Rectangle sRec = spriteSheet.GetRectangle(current.IdFragment);

 181:                  spriteBatch.Draw(img, AnimationList[i].Position - new Vector2(sRec.Width / 2, sRec.Height / 2),

 182:                      sRec, Color.White);

 183:              }

 184:              spriteBatch.End();

 185:

 186:              base.Draw(gameTime);

 187:          }

 188:      }

HideΔ

E questo è il codice per il Game:

Show∇

   1:      public class Game1 : Microsoft.Xna.Framework.Game

   2:      {

   3:          GraphicsDeviceManager graphics;

   4:          SpriteBatch spriteBatch;

5:

   6:          SpriteFont font;

7:

   8:          AnimationManager animMng;

9:

  10:          //stato del mouse al ciclo precedente

  11:          MouseState lastMS;

12:

  13:          public Game1()

  14:          {

  15:              graphics = new GraphicsDeviceManager(this);

  16:              Content.RootDirectory = "Content";

17:

  18:              graphics.PreferredBackBufferWidth = 800;

  19:              graphics.PreferredBackBufferHeight = 600;

20:

  21:              TextColl.Initialize();

  22:              SpriteSheetCollection.Initialize();

  23:              AnimationsDescCollection.Initialize();

24:

  25:              Components.Add((animMng = new AnimationManager(this)));

26:

  27:              IsMouseVisible = true;

  28:          }

29:

  30:          protected override void Initialize()

  31:          {

  32:              base.Initialize();

  33:          }

34:

  35:          protected override void LoadContent()

  36:          {

  37:              spriteBatch = new SpriteBatch(GraphicsDevice);

38:

  39:              font = Content.Load<SpriteFont>("font");

40:

  41:              TextColl.TextureCollection.Add(0, Content.Load<Texture2D>("prova"));

42:

  43:              SpriteSheet ss = new SpriteSheet(0, 5, 2);

  44:              SpriteSheetCollection.SpritesSheetCollection.Add(0, ss);

45:

  46:              AnimationDesc ad = new AnimationDesc();

  47:              ad.FrameList.Add(new Frame(0, 0));

  48:              ad.FrameList.Add(new Frame(0, 1));

  49:              ad.FrameList.Add(new Frame(0, 2));

  50:              ad.FrameList.Add(new Frame(0, 3));

  51:              ad.FrameList.Add(new Frame(0, 4));

  52:              AnimationsDescCollection.AnimationCollection.Add(0, ad);

53:

  54:              lastMS = Mouse.GetState();

  55:          }

56:

  57:          protected override void UnloadContent()

  58:          {

  59:          }

60:

  61:          protected override void Update(GameTime gameTime)

  62:          {

  63:              if (Keyboard.GetState().IsKeyDown(Keys.Escape))

  64:                  this.Exit();

65:

  66:              if (lastMS.LeftButton == ButtonState.Released && Mouse.GetState().LeftButton == ButtonState.Pressed)

  67:              {

  68:                  MouseState ms = Mouse.GetState();

  69:                  Animation anim = new Animation(0, new Vector2(ms.X, ms.Y));

  70:                  animMng.AnimationList.Add(anim);

  71:              }

  72:              lastMS = Mouse.GetState();

  73:              base.Update(gameTime);

  74:          }

75:

  76:          protected override void Draw(GameTime gameTime)

  77:          {

  78:              GraphicsDevice.Clear(Color.CornflowerBlue);

79:

  80:              base.Draw(gameTime);

  81:          }

  82:      }

HideΔ

Come potete vedere non è nulla di trascendentale o di così complicato come poteva sembrare.
Vi allego anche la soluzione per Xna4 (se il link non funziona contattatemi):
Soluzione Visual Sutdio

Ed ecco un buonissimo sito con tantissimi spriteSheet!
Sprite Database

Alla prossima!
Odino

The Xna-Way: Tutorial 9 (Trick): Ordine dei DrawableGameComponent/GameComponent

2011-04-16T21:16:00.005+02:00

Vi siete mai trovati a dover aggiungere diversi GameComponent al vostro progetto?
Bè credo di si, dato che sono il componente fondamentale su cui si basa XNA.

E scommetto che molti si sono trovati nella situazione in cui un Component esegua il metodo Update prima di un altro, o che vengano eseguiti i metodi Draw in un ordine che non è quello desiderato... producendo in questo modo effetti del tutto errati.

Ma c'è un semplicisso modo per ovviare a tutto questo.
La classe GameComponent espongono due proprietà interessanti:
- UpdateOrder: indica in quale ordine i componenti devono eseguire il loro metodo Update (questo se sono attivi). L'ordine è relativo agli altri componenti presenti nella stessa collezione. Naturalmente i GameComponent con valori più bassi verrano aggiornati prima.
- DrawOrder: indica in quale ordine verrano eseguiti i metodi Draw dei vari componenti.

Queste due proprietà sono molto utili quando si lavora con componenti che si devono "passare" dai, o per i quali è necessario che lo stato (o la parte di stato) del gioco sui cui operano sia stata prima aggiornata da un altro componente.

Lo stesso dicasi per l'ordine del rendering della scena. Ciò torna molto utile nel caso si abbia più DrawableGameComponent i quali operano su SpriteBatch differenti per esempio. Così potremmo delegare ai vari componenti il render di una parte della vista, per poi comporre il tutto assieme con pochissimo sforzo.

Spero vi sia utile (a me lo è stato^^).
Per qualsiasi dubbio contattatemi pure.
A presto.

Odino

X-RPG Builder 2D - aggiornamento 8

2011-04-05T13:35:00.002+02:00

Lo sviluppo del progetto è attualmente sospeso causa studi universitari, che mi portano via la maggior parte del tempo, e nel tempo che mi rimane mi sono messo a sviluppare un altro proggetto, che spero porterà alla nascita di un Indie Game da poter poi inserire nel Market Place della Microsft.

Per qualsiasi domanda sul progetto X-Rpg Builder 2D (quando riprenderà, come funzionano certi particolari, come sono state realizzate le strutture dati, etc) contattatemi via e-email.

A presto.
Odino
E questo è il resto.

X-RPG Builder 2D - aggiornamento 7

2011-03-13T10:14:00.005+01:00

E' passato un bel di tempo dall'ultimo aggiornamento.
Cosa è successo nel frattempo?

Tante cose. Tanti intoppi, altre faccende da sbrigare che mi hanno tenuto lontano dallo sviluppo.
Solo da poco ho ripreso a mettere mano al codice.
Sto ora lavorando alla parte game del progetto, sviluppando i components e le classi che dovranno mandare effettivamente avanti il gioco.
Ho sviluppato parte del sistema di generazione e gestione delle azioni (e del corrispettivo codice da eseguire) scatenate dagli eventi di gioco.
Per esempio adesso sto lavorando sulla parte del menù di interazione con l'untente, e questo è l'effetto per ora ottenuto.

C'è ancora molto da fare.
E con il ricominciare delle lezioni può darsi che il tempo che passerò a sviluppare il tutto diminuirà drasticamente. Ma piano piano si porterà tutto a compimento.

Alla prossima!

X-RPG Builder 2D - aggiornamento 6

2011-01-06T19:30:00.003+01:00

Piccolo aggiornamento sull'editor ed in parte sul game Engine.

Ho dovuto separare in modo drastico la libreria base per l'Rpg dal resto della logica dell'applicazione, in modo da avere un ottimo riutilizzo del codice tra editor e motore del gioco.

Adesso l'engine e l'editor specializzano solo le classi necessarie alla gestione delle immagini, mentre la parte di caricamento è rimasta la solita.
Quindi ho dovuto riscrivere buona parte dell'engine, e ho cominciato a strutturare i vari gameComponents che dovranno girare in background nel gioco.

Per quanto riguarda l'editor adesso sto strutturando la gestione e la personalizzazione degli eventi, compreso il codice degli eventi. Il codice degli eventi potrà anche portare all'esecuzione di codice C# personale.
Quello che voglio fare è ottenere, dalla struttura del codice degli eventi, la produzione di codice C# che dopo dovrà essere compilato ed eseguito: cioè voglio che durante la fase di esportazione del progetto mi venga generato il codice C# relativo allo pseudo codice degli eventi. In questo modo non dovrò costruirmi un interprete personalizzato per il codice.

Eccovi un'immagine di come si presenta in questo momento l'editor degli eventi:

Vi saluto.
A presto con altri aggiornamenti :)
Ciau

X-RPG Builder 2D - aggiornamento 5

2010-12-05T21:51:00.003+01:00

Questo non è un vero e proprio aggiornamento, ma solo una comunicazione.

Dato che sto seguendo le lezioni dei corsi universitari adesso ho poco tempo (come poche energie) da dedicare a questo progetto, che sta quindi procedendo molto a rilento.
In questo periodo mi sono concentrato sull'editor (e non sul motore del gioco) in modo da poter produrre tutti i dati di cui la mia applicazione finale potrà aver bisogno.
Sono state aggiunte diverse funzioanlità all'editor, ma ancora manca molto da fare.

Una della perti più importanti da fare (da progettare e da implementare), e che sarà un po' il cuore di tutto è la gestione degli eventi. Questa parte (a cui piano piano sto pensando) rappresenterà il nucleo primario del funzionamento del gioco.
Quindi è fondamentale ponderare bene la sua costruzione, pena una grossa fila di eresie.

Spero a presto con dei veri aggiornamenti.
Odino

X-RPG Builder 2D - aggiornamento 4

2010-10-08T13:45:00.003+02:00

Aggiunta la gestione della creazione e modifica della animazioni per le skill.
Queste animazioni potranno essere utilizzate anche al di fuori delle battaglie, quindi potranno essere utilizzate come "effetti" speciali nell'esplorazione della mappa.

L'ultima versione di Rpg-maker permetteva l'utilizzo di sole due immagini (se ricordo bene) come fonte per i frame da utilizzare per definire le animazioni.
Ho invece deciso che nel mio editor non ci siano limiti al numero di immagini che è possibile utilizzare come fonte per i frame.
Non ci sono ne limiti al numero di immagini che possono comporre un frame, ne al numero di frame che è possibile aggiungere all'immagine. Si possono creare animazioni lunghe a piacimento.

Certo manca ancora tutta la gestione degli effetti sonori e di altri effetti grafici.
Ma ora come ora sto mirando a produrre più roba possibile ed avere un qualcosa di funzionante.
Per fare questo ho anche cominciato a definire le altre strutture dati di cui avrò bisogno per far funzionare il tutto, tra cui ci sono gli Status che si possono subire (sia per i nemici che per gli alleati), gli elementi (fuoco, acqua, etc) che sono presenti nel gioco e che determineranno l'efficacia delle abilità.
Ora c'è da definire le abilità/magie, gli equipaggiamenti, gli oggetti dell'inventario. Insomma il lavoro non manca.
Quello che mi "spaventa" un po' di più è la creazione di formule bilanciate per il calcolo dei danni che verranno inferti dai/verso i mob.
Quella sarà una parte bella complessa mi sa...
Ma ci arriverò piano piano.

Alla prossima.
Sperando di riuscire ad uppare anche un video della gestione delle animazioni.

A presto!
Odino

X-RPG Builder 2D - aggiornamento 3

2010-09-22T11:18:00.002+02:00

Altro aggiornamento su questo piccolo (almeno per ora) editor.

Credo di aver ormai completato la gestione dei tileset, e di aver implementato anche la gestione dei "livelli" dei tileset di tipo B (quelli che su RPG-Maker erano dedicati a tetti e muri).
Ecco un'immagine di come vengono gestiti nel gioco (e nell'editor di mappe naturalmente).

Direi che come risultato può andare più che bene.
Non mi pare di vedere difetti nel render o nella continuità dei tileset.
Se ne notate perfavore ditelo! ^_^

Alla prossima!
Odino

X-RPG Builder 2D - aggiornamento 2

2010-09-18T10:56:00.002+02:00

Eccomi con un altro aggiornamento su X-RPG Builder 2D.
Sembra che più sia stressato, più abbia mal di testa e meglio riesca a lavorare...
vabbè andiamo avanti.

Ho aggiunto la gestione degli altri 2 tile set utilizzati da RPG Maker VX, e cioè il tile set per le montagne e le foreste/erba (sempre di 2 celle orizzontali per 3 celle verticali) e quello per i muri/tetto (di 2 celle per 2 celle).
Questo è uno screen preso dal mio editor:

come si può vedere il risultato non è male, cioè almeno io ne sono abbastanza soddisfatto (c'è ancora da gestire qualcosa ma per ora può bastare, i dettagli li puntualizzerò più avanti).

Questo invece è il gioco in esecuzione nel progetto XNA

Gli npc in automatico sono solo come prova per il controllo delle collisioni.
Quella parte va ancora completata.

Lo sviluppo di X-RPG Builder (il mio rpg maker su xna) continua!

Alla prossima con altri aggiornamenti ^_^

Ciao
Odino

Pagina con il riassunto di quanto fatto fino ad ora (contiene tutti i post riguardanti questo progetto).

X-RPG Builder 2D - aggiornamento 1

2010-09-07T22:21:00.005+02:00

Dopo molto aggiorno questa pagina.
Tutta colpa della preparazione della tesi, che mi porta via sempre tanto tempo.
Comunque è stata aggiunta qualche piccola funzione:
- sono state aggiunte le varibili (contentitori per valori) che possono essere a livello di mappa (visibili ed utilizzabili solo all'interno della mappa in cui sono definite) o a livello di progetto (visibili da ogni parte). Non sono ancora utilizzate
- è possibile impostare il party iniziale
- è possibile aggiungere e definire delle armi
- adesso quando si effettua l'esportazione del progetto vengono salvati nella directory principale tutti i file necessari e vengonoa aggiunti in automatico al progetto XNA
- vengono salvati ed aggiunti al content project del gioco XNA tutte le immagini necessarie al funzionamento del gioco

Sto ora lavorando per poter definire gli altri oggetti utilizzabili durante il gioco (equipaggiamenti, oggetti dell'inventario, oggetti per delle quest, etc), in modo da poter avere una base su cui cominciare a programmare la gestione degli eventi, dalla loro creazione nell'editor al loro utilizzo all'interno del gioco.

Pagina con il riassunto di quanto fatto fino ad ora (contiene tutti i post riguardanti questo progetto).

Mage Masher (o Tritamago) WIP 2

2010-08-11T13:19:00.002+02:00

Dopo un po' di lavoro ecco a voi il rendering della versione finale (almeno credo) della tritamago di Gidan.

Per la versione a piena risoluzione (4800x2600) dovete scaricarla da qua:
DeviantArt

Spero vi piaccia.

A presto :)
Odino

Mage Masher (o Tritamago) WIP 1

2010-08-10T09:15:00.004+02:00

Dopo tanto mi sono deciso a rimettermi a lavorare un po' con il 3D.
Tanto per riprendere un po' la mano.
Devo dire che mi trovo un po' arrugginito (anche se non del tutto corroso XD).

Comunque vediamo di spiegare quello che si vuol tentare di fare ^^

Molti avranno giocato a Final Fantasy IX (gioco che in questo periodo mi vorrei proprio rigiocare :D, anche se quella è un'altra storia xD), e il personaggio principale Gidan (Zidane) Tribal come molti usanno utilizzava delle daghe.
Questa è la sua daga più famosa, tanto che se ricordo bene anche nei vari artwork è rappresentato con questa, la ormai famosa tritamago.
Dato che molto tempo addietro mi ero cimentato nella realizzazione dei Gunblade di Squall e Seifer (cosa che mi è piaciuta tantissimo) ho deciso ora invece di mettermi a realizzare nuovamente le armi dei personaggi dei vari Final Fantasy.
Ed ecco a voi il risultato (della sola modellazione) della Tritamago, per la quale ho impiegato più o meno un'oretta.

Appena avrò tempo e voglia mi cimenterò con il rendering, anche se ancora devo fare delle modifiche alla mesh ed al modello (voglio aggiungere più particolari).

Se poi avrò modo posterò anche delle immagini progresstive dei vari lavori in modo che si possa avere un'idea del come è stato realizzata la modellazione.
Se qualcuno è interessato ai modelli mi contatti e vediamo se glieli mando ^^

A presto :)
Odino

Apertura nuova pagina

2010-08-08T21:20:00.003+02:00

Annuncio l'apertura della pagina relativa ad un mio nuovo progetto, che piano piano sto portando avanti.

A questo link
X-RPG Builder 2D
potrete trovare di volta in volta informazioni più approfondite a riguardo di questo progetto.

Spero a presto con altre notizie ^^
Ciau!

Piccolo editor di terreni free

2010-07-06T10:08:00.011+02:00

Approfitto dopo tanto di un momento di pace per scrivere e postare qualcosa che spero possa interessare a molti.
Rendo infatti disponibile il codice sorgente di questa mia applicazione, un piccolo terrain editor che ho realizzato per un esame universitario.
Il perchè di questa mia scelta: primo perchè credo che nonostante le grandi imprecisioni, gli errori e i bug che ci possono essere, può essere di interesse per qualcuno, sia per i concetti applicati sia come punto di partenza per altro.
Secondo perchè lo considero io stesso un progetto ormai superato, che però mi ha fatto imparare tanto.
Infatti lo userò come base teorica per realizzare ben altro.

Cominciamo con una piccola spiegazione:
l'interfaccia dell'applicazione è questa:

Per un riassunto veloce dei comandi e delle funzioni basta che andate sulla voce "comandi" sotto "?" nel menù in alto.

La prima cosa che dovete fare è creare un nuovo livello. Dopo potete o agire direttamente con i mouse sul terreno o caricare una Height Map (tramite il bottone nella colonna di destra). Ecco cosa viene realizzato caricando una delle HM che ho inserito come prova.

La modalità di editing è modale: se vedete bene in alto a sinistra c'è un gruppo di radio button che vi dicono attualmente cosa state andando a modificare nel livello, se il terreno, le texture o i modelli. Quando siete in una modalità agite solo su quella parte.
Potete cambiare la modalità cliccando sul radio button relativo o premendo 'T'.
Potete texturizzare il terreno a vostro piacere utilizzando le 4 texture in alto a destra. Per cambiare la texture da usare basta farci click sopra, mentre se proprio volete caricare un'altra immagine al suo posto dovete farci doppio click.

Per inserire i modelli nella scena dovete prima caricarli: andate sotto la scheda Objects e cliccate su "Load Model". Selezionate il modello da caricare e date l'ok. Il modello verrà "compilato" al volo nel formato compatibile con XNA e potrete poi utilizzarlo nel livello. Se ci cliccate sopra nel riquadro sottostante vedrete anche l'anteprima del modello in questione.

Provatelo poi ditemi.

Immagiamo di aver salvato questo livello:

Per caricarlo all'interno di un progetto XNA game dovete seguire alcuni passi:
1) dovete aggiungere il file *.map che viene generato quando salvate la mappa al progetto XNA e impostare le sue proprietà in modo che venga copiato nella directory finale del progetto durante la compilazione
2) Dovete copiare la bitmap del livello, che ha lo stesso nome del file *.map, e le texture usate per texturizzare il terrain sotto la directory "Content\Textures" del vostro gioco XNA
3) dovete copiare i modelli che avete utilizzato nel livello sotto la directory "Content\Models"
4) dovete copiare le texture usate dai vostri modelli nel gioco XNA mantenendo lo stesso percorso relativo rispetto ai file di origine
NOTA: Naturalmente tutte queste risorse vanno aggiunte al progetto Content del gioco XNA per permettergli di elaborarle.
A questo punto tutto è fatto. Basta che lanciate il il programma e vi ritroverete con il vostro livello caricato e pronto all'uso.
Ecco un'immagine dell'esempio allegato:

Vi allego di seguito la soluzione per Visual Studio 2008.
Per far girare il programma è necessario aver installato XNA 3.1 e il .Net Framework 3.5.
Per qualsiasi cosa, consigli, problemi, lamentele, critiche commentate il pure, o mandate un'email.
Per favore, se scaricate e provate il codice commentate, almeno mi lasciate un feedback sul mio lavoro ^^

Codice sorgente

Alla prossima :)
Alessio (Odino)

Apertura nuovo blog

2010-06-13T20:30:00.003+02:00

Come preannunciato tempo fa, ho aperto dopo tanto il nuovo blog destinato a raccogliere quei post che non erano attinenti all'informatica, oltre a contenere i nuovi post di tal genere che pubblicherò.

Il link è: AsgardWalls
Chi vuole darci un'occhiata faccia pure (se siete tanto coraggioni o incoscienti).
In un'epoca dove tutti possono dire quello che vogliono ho pensato che era il caso di fare lo stesso. Almeno ci si sfoga un pochino.

Alla prossima!

Avviso

2010-05-31T09:01:00.003+02:00

Comunicazione di servizio:
per esigenze particolari dettate dalla mia mente contorta, forse qualcuno potrà notare che una trentina di post sono scomparsi dal blog.
Questo perchè ho deciso di ripulire il blog, lasciando questo solo per gli articoli riguardanti la programmazione.
Gli altri articoli/post andranno a finire in un altro blog, che vedrò di aprire il prima possibile, dove andrò a mettere tutta quella roba che non riguarda il mondo della programmazione (quindi recensioni, riflessioni, lamentazioni, bestemmioni vari).
Abbiate un po' di calma che ora come ora di tempo ne ho poco quindi la cosa andrà a rilento.

Saluti dal vostro amichevole Odino di quartiere (non mi uccidete per questa citazione storpiata XD)

Tanti auguri a me!

2010-04-17T11:23:00.002+02:00

No, non sono impazzito...
Era ormai il lontano 06/04/2009 quando veniva pubblicato su questo blog il primo post, il primo post dopo il Ragnarok.
Tante cose sono accadute da allora, alcune buone ma la maggior parte mica tanto...

Tra una disavventura e l'altra siamo andati avanti, si è pubblicato un po' di roba (non tanta, ma ci si è provato).

L'intenzione di continuare, nonostante il poco tempo, c'è sempre.
Dovuta anche al fatto che bene o male un po' di visite ci sono sempre, per quanto questo sia un blog un po' strano...

Quindi faccio gli auguri a questo blog! Che possa continuare a prosperare!
E che la luce di Odino lo protegga!

Small Tutorial: testo a scomparsa tramite JavaScript (JS)

2010-04-12T20:27:00.013+02:00

Quanti di voi hanno visto quei fantastici siti/blog dove ci sono i blocchi di testo che appaiono/scompaiono magicamente quando si clicca su dei link...
Sono fantastici vero? ^^

Bè oggi voglio spiegare un pochino come si fanno...
e vedrete che non è poi così complicato :)

Intanto quello di cui avete bisogno è di una funzione javaScript.
Senza entrare nel dettaglio del linguaggio quello che dovete aggiungere è quanto segue:

Questa funzione recupera dalla vostra pagina l'elemento con ID passato, e controlla se il suo stile display vale block o none.
In caso sia block lo imposta a none, e viceversa.

Ora, quando volete avere del testo/contenuti che compaiono/scompaiono fate un qualcosa di questo tipo:

<h2 style="cursor: pointer;" onclick="openclose('myElm');">Show∇</h2>
<div id="myElm" style="display: none;">
<h2 style="cursor: pointer;" onclick="openclose('myElm');">HideΔ</h2>
</div>

All'interno del div mettete quello che vi serve e avrete un effetto simile ^^

Show∇

byez^^

Internet Explorer.... una chiavica di browser...

2010-03-29T14:47:00.040+02:00

In un mondo pieno di Browser, in continua evoluzione, dove quasi ogni giorno centinaia di utenti decidono di navigare su internet...
Perchè la gente continua ad usare IE?

Sto avendo modo ultimamente di di lavorare a delle applicazioni internet, e ogni volta che faccio qualche modifica devo controllare come risponde il tutto su Fire Fox (il quale di solito lavora bene, raramente ti fa incazzare), per poi passare a Internet Explorer.

Come mai solo questi due direte voi?
Perchè da soli fanno circa il 95% delle visite di un sito. Lo so che chi usa Opera o Chrome ora mi linceranno, ma non ci posso far nulla, lo dicono le statistiche.
E le statistiche (mie) mi dicono che ogni volta che devo vedere lle modifiche su IE, il 70% delle volte sono bestemmie!

Nel senso che:

funziona ma con qualche piccola differenza

funziona così così

funziona male

non funziona per nulla

Ma quando gli costerà alla Microsoft mettere una schiera di sviluppatore/programmatori/debuggatori (me lo passate sto francesismo?) a correggere il tutto e a farlo funzionare per bene?
E invece no...
Si ostinano ancora a fare come vogliono loro...

VI PREGO! ADERIAMO AGLI STANDARD CAVOLO!

Una piccola vendetta per gli utenti di IE?
Beccatevi questo:

Sei un mona?
Se vedi il bordo smussato hai la superato la prova e non sei un mona.

Se vedi un fotutto rettangolo sei un mona! Cambia subito browser!
Firefox
Opera
Chrome

Alla prossima!

The Xna-Way: Terrain Editor - Update 1

2010-02-10T16:18:00.007+01:00

Aggiornamento sul terrain editor.

Dopo diversi giorni di lavoro, che sono stati più di quanto avessi preventivato all'inizio (non tanto per la complessità del problema, ma il fatto è che sono stato rallentato da problemi personali) direi che sono quasi alla fine della base di questo progetto.
Cosa è stato fatto in questo periodo?

Il codice è stato organizzato in modo che il controllo/editor del livello contenga due oggetti separati definiti come TerrainEditor e ModelLevelEditor. Tali oggetti vanno a riferire lo stesso oggetto Level, solo che il promo va a modificare il terreno e le texture del terreno, mentre il secondo da la possibilità di modificare in modo agevole i modelli presenti nel livello.

Questi oggetti come si è capito danno specifiche funzioni che agiscono su una parte del modello dell'applicazione.

Tra le caratteristiche comuni ad entrambi c'è la coda delle operazioni svolte: posso cioè tornare indietro con le operazioni svolte e ripristinare lo stato precedente alla modifica fatta, questo per ogni operazione possibile (editing del terreno, editind delle texture del terreno, editing delle trasformazioni spaziali del modello). Ancora è da rifinire e perfezionare, ma per ora funziona.

Ho aggiunto la possibilità di importare oggetti 3D a runtime, cioè non compilati a posteriori da XNA tramite il Visual C# o VS. Questa parte devo dire mi ha impegnato un po', ma solo per il fatto che non capivo come re-indirizzare il compilatore alla giusta versione delle dll da usare.
Ora, tramite un sistema di Builder e ContentManager, "compila" a tempo di esecuzione i file che deve importare nella scena. Il tutto rallenta un po' (dato che la compilazione/importazione dei modelli nel formato compatibile con XNA impiega un po' ti tempo; forse potrei ottimizzare aggiungendo in futuro la compilazione in un thread separato, in questo modo, almeno al caricamento di un livello precente otterrei un tempo minore), ma funziona.
Unica "pecca": dato che non riesco ancora a trovare il riferimento a tutti i file necessari per la compilazione di un modello (texture e simili) sarà compito di usa il modello copiare poi nella cartella/directory che più preferisce i file necessari al corretto funzionamento del modello nel livello.

A cosa serve poter importare oggetti nel livello se poi non si possono usare? Ho aggiunto quindi la possibilità di inserire/eliminare modelli dal livello tramite il mouse. Lo stesso dicasi per quanto riguarda la traslazione/rotazione/scaltura degli stessi.
Per le trasformazioni spaziali degli oggetti ho creato ed aggiunto degli assi cartesiani, per ora molto semplici, che permettono di postare l'oggetto.

Dato che le modifiche possibili sono diventate varie, ho deciso di rendere modulare il modo di agire sui dati.
L'applicazione permetterà di modificare la parte del modello che vogliamo modificare: tramite dei radio button (o con un short-cut) si può passare dalla modalità di editig del terreno, alla modalità di editing delle texture ed infina a quella dei modelli.
Forse è un po' scomodo all'inizio, ma se si pensa che in altri programmi professionali fanno cose simili (ok forse è esagerato comparare questo sgorbio che sto facendo con programmi professionali, ma a qualcuno/qualcosa ci si deve pur ispirare no?).

Aggiunta la possibilità di caricare nuove immagini da usare nei brush per la modifica del terreno, e queste immagini poi saranno copiate nella directory dei terrain brush e ricaricate al riavvio successivo.
Credo che andrò a fare una cose del genere anche per le texture usate per il terreno, in modo che quando si vorrà poi riusare il livello creato in un gioco (ma chi mai andrà a farlo mi domando io XD) almeno avrà parte dei dati raggruppati e più facilmente utilizzabili.

Per ora non credo di avere altro da aggiungere.
Se ho dimenticato qualcosa aggiungerò in seguito.

Vi lascio con uno screen del programma:

Per le percentuali di lavorazione:
Terrain Editor Journal

Alla prossima ^^

PS: non credo che molti avranno qualcosa da dire, ma in caso contrario che dite tutto quello che vi passa per la testa! Curiosità, possibili correzioni, cosa da fare/aggiungere.
E se avete qualche curiosità sul codice ditelo, e vedrò di pubblicarlo! (almeno in parte ^^)

The Xna-Way: Terrain Editor Journal

2010-01-18T16:30:00.009+01:00

Questo post sarà il giornale di sviluppo che dedicherò al terrain editor.
Aggiornerò di volta in volta con le modifiche che farò, con le possibili modifiche/update da fare al programma, gli errori (e quando riesco a risolverli anche come ho fatto XD).
Se poi ci saranno articoli relativi a pezzi di codice del Terrain Editor saranno linkati anche qui.

Quello che mi sono prefisso di fare inizialmente era di creare un Terrain Editor, in modo da poterlo poi utilizzare per creare i livelli di gioco per i miei futuri progetti (sempre pensare in grande perchè poi a forza di tagliare resta sempre poco XD).
Ho quindi poi deciso di ampliare il progetto permettendo di aggiungere oggetti alla scena.
Quindi da "semplice" terrain editor sono passato a voler fare un "semplice" Level Editor (con un formato mio personale).

I fondamenti sono i seguenti:
- Uso di un'immagine come Height Map (HM) per la creazione del terreno di base.
Un'immagine ha 4 canali per il colore (RGBA), ed ho deciso di utilizzare solo le informazioni presenti nel canale R per la creazione del modello del terreno. In questo modo gli altri canali potranno essere utilizzati per memorizzare altre informazioni (per esempio le zone in cui è possibile "camminare", posizione di alcuni oggetti di scena, etc)
Usando il valore di un singolo colore per l'altezza del vertice, il valore dell'altezza può variare tra 0-255 (estremi compresi).
Per ampliare il range di valori posso utilizzare un fattore di scala (positivo) per il quale moltiplicare il valore dell'altezza del vertice.
Avrò un fattore di scala anche per la dimensione del del modello lungo gli assi X-Z (in questo modo il fattore di scala per la larghezza sarà diverso e distinto da quello per l'altezza).

- Possibilità di editare il terreno, modificando l'altezza dei vertici che compongono il modello.
Cioè saranno dati dei brush con i quali sarà possibile modificare la mesh del terreno. Ad ogni brush (a seconda della funzionalità che deve espletare) può avere associata un'immagine, la quale verrà utilizzata per modificare la posizione dei vertici. L'immagine associata potrà essere cambiata a seconda del tipo di modifica che si vuole fare, e sarà in BN (o in caso non sia in BN verrà usato solo il valore del canale R, come per la HM usata per costruire il terreno).

- Possibilità di salvare il terreno prodotto come immagine.
Per quando ci saranno dei possibili modelli sul terreno dovranno essere salvati anche le informazioni sui modelli (forse serializzando con XML), come anche le informazioni sulle luci della scena, etc.

- Possibilità di utilizzare 4 texture per la colorazione del terreno. Per ora il numero è limitato a 4 per una maggiore semplicità di programmazione (e per la struttura dei vertici usati): difatto utilizzare più di 4 texture è "la stessa cosa" che usarne 4, solo che i casi da discriminare sono di più. Sarà possibile utilizzare le varie texture in base all'altezza dei vertici, o texturizzare a mano il terreno.

A presto per degli aggiornamenti

Stato attuale:

Caricamento HM e creazione terreno partendo dall'immagine: 100%
Caricamento altre informazioni dall'immagine: 100%
Salvataggio terreno editato: 100%
Uso di un file XML per la memorizzazione di altre informazioni sul livello: 100%
Definizione di Brush personalizzati atti alla modellazione del terreno: 100%
Salvataggio/caricamento brush ed immagini dei brush: 100%
Possibilità di texturizzare il modello in base all'altezza dei vertici o a mano: 100%
Possibilità di creare ed aggiungere nuovi brush: 0%
Possibilità di modificare le texture usate dal modello: 100%
Possibilità di aggiungere/gestire modelli al livello: 100%
Possibilità di aggiungere/gestire luci nel livello: 0%
Possibilità di fare degli screenshot/render del terreno: 0%
Algoritmo di intersezione mouse-VS-poligoni: 100% (Implementato algoritmo ricorsivo a partizione dello spazio per la l'indificazione del vertice più vicino al puntatore)
Algoritmo di editig dei vertici del modello: 100%
Algoritmo di texturing: 100%

End

The Xna-Way: Terrain Editor

2010-01-13T16:07:00.004+01:00

Come avevo detto tempo fa, non ho molto tempo per scrivere qualcosa su XNA da postare qua, ma non per questo vuol dire che non stia andando avanti in qualche modo.

Ho recentemente iniziato un progetto per l'università (o almeno spero che possa usarlo per un esame universitario), che per ora ha il nome di Terrain Editor.
Lo sto sviluppando usando C# ed XNA (se no cola cavolo che ne parlavo sotto Xna-Way XD), e per ora si prospetta come un semplice editor di terreni.
Alcune immagini:

Quello che mi sono prefisso di fare è di creare un piccolo editor di livelli, in modo da poter creare delle mappe da poter usare in un gioco o quello che ci pare.
I "livelli" per ora composti solo dal terreno, sono costruti partendo da delle immagini (usate come Height Map), in modo da poter usare i colori per posizionare i vertici.
In seguito voglio aggiungere altre caratteristiche, tra le quali per ora ho messo:
- editare il terreno (se no che Terrain editor sarebbe...) (già in parte implementato)
- definire zone in cui è possibile camminare o meno
- possibilità di aggiungere oggetti al livello e posizionarli nella scena
- Multitexturing del terreno (questo già in parte implementato)

poi mano a mano che mi vengono in mente le aggiungerò.
Quando avrò tempo credo che posterò qualche pezzo di codice più interessante (non che per il momendo ce ne sia poi molto).
Spero che il progetto vi piaccia (e nel caso possa usarlo come progetto d'esame che piaccia anche al prof!).

Un salutone!
A presto!

The Xna-Way: Avviso

2009-12-07T16:00:00.001+01:00

E' con dispiacere che informo, chi è interessato, chi mi segue, e quei pochi che capitano su queste pagine (forse pure per errore), che non credo aggiungerò altri tutorial/codice/guide su XNA per minimo un mese.

Motivo?
Studio, università, lavori da consegnare, progetti da completare e discutere, problemi vari, e tanto altro ancora!
Se ce la farò vedrò di pubbliacare qualche post di commento/recensione, ma non prometto nulla.

Per chi volesse contattarmi o simili vi rammento che sono su msn e rispondo a questo indirizzo e-mail.
odinoa@hotmail.it

Saluti!

FUUUUUU.... cioè quando non ti resta altro da fare!

2009-11-13T17:46:00.003+01:00

Vi è mai capitato di non sapere dove sbattere la testa?
Di avere delle cose da fare ma altre vi si sovrappongono e dovete rimandare?
Oppure solo di provare una forte rabbia per qualcosa che non va per il verso giusto?

Bè ecco come mi sento quando provo cose del genere!

Sinceramente non saprei in qualche altro modo esprimere la rabbia e la frustrazione che alle volte si prova!
E questa immagine rende bene come ci si sente XD

Il soggetto non è mio! Il FUUUU come viene chiamato è nato sulle Chan (se ricordo bene) e avendo passato una giornata pesa, persa a compilare della cavolo di librerie che non ne volevano sapere di partire, quando poi ce l'ho fatta per liberarmi un po' ho fatto questa... cosa (XD) in zBrush.
Circa 40 minuti di lavoro... o meno... bo non lo so (intanto facevo anche altre cavolate).
Se qualcuno lo vuole mi chieda il file e glielo invio per posta elettronica.

Buon FUUUU a tutti!
Meglio un FUUUU che spaccare i mobili di casa XD

Alla prossima!

The Xna-Way: Tutorial 9: Fractal Generator

2009-11-10T16:50:00.000+01:00

Come avevo preannunciato nell'ultimo post, ho realizzato un piccolo componente che genera alcuni frattali.
Il tutto è scritto in .Net ed utilizza gli strumenti forniti da XNA per creare e manipolare le immagini usate per la generazione dei frattali.
Il "programma" che illustrerò è abbastanza lunghetto rispetto agli altri, ma vedrò nel possibile di spiegarlo al meglio delle mie capacità.

Come sempre vi esorto a farmi notare se ho detto delle boiate immani!

Nota: nell'ultimo post avevo fatto vedere diverse immagini di frattali realizzate con il codice che andrò ad illustrare, però il codice che vi fornirò adesso potrà generare un solo tipo di frattale, e cioè il frattale di Mandelbrot.
Gli altri non li metterò per ora, anche se il codice è molto simile a quello che userò qua.

Intanto cominciamo col dire come ho pensato il tutto:
>il calcolo che dobbiamo fare è dato dalla successione:
z(n+1) = z(n)^2 + c
dove z è il valore del punto che vogliamo calcolare, e c è una costante che dobbiamo sommare di volta in volta
per z(0) valore sarà c
per z(1) il valore sarà c^2 + c
e così via.

>i punti su cui calcoliamo la successione sono quelli del piano complesso, quindi dovremo fare tutti i calcoli utilizzando l'algebra dei numeri complessi

>il valore di c cambia a seconda di quale punto del piano complesso stiamo calcolando il valore

>un punto appertiene all'insieme di Mandelbrot se Zn è in modulo minore di 2, dove n indica per quante volte dobbiamo ripetere il calcolo prima di considerare il punto in questione appartenente all'insieme. Quindi se dopo un numero i di ripetizioni del calcolo della successione il valore supera 2, il punto non appartiene all'insieme e verrà colorato in modo particolare, mentre se il punto appartiene all'insieme sarà colorato di nero.

NOTA: per la gestione dei calcoli con i numeri complessi ho usato una classe che ho trovato su internet, del quale ho fatto brutalmente copy-paste. Lo che di solito non si fa così, ma non era la parte dui numeri complessi che mi interessava implementare. Sicuramente l'uso di questa classe può aggiungere un po' di tempo di calcolo in più, quindi per velocizzare avrei potuto implementare il calcolo a manina, ma la "complessità" dei numeri complessi (scusate il gioco di parole XD) mi ha tolto la voglia.

Avrò quindi bisono di sapere in quale zona del piano complesso sto andando a calcolare la successione, quindi dovrò definire il limite inferiore e superiore per l'asse reale (considerato l'asse delle ascisse) e l'asse complesso (considerato delle ordinate).
Poi dovrò sapere quanto è lungo il lato delle ascisse e delle ordinate del piano (cioè la differenza tra il limite superiore ed inferiore degli assi), dato che questi valori poi mi servono per calcolare il valore di incremento. Si deve considerare che la texture (che rappresenta il frattale) sarà una "approssimazione" del piano complesso, e dato che non posso avere tanti pixel quanti sono i punti del piano (dato che sarebbero infiniti) devo assegnare ad ogni pixel un punto del piano e calcolare il valore per quel punto, e per fare ciò, quando passo da un pixel al successivo, devo sapere di quando avando/devo incrementare per passare al punto successivo.

Spieghiamo meglio questa cosa dei pixel...
Come forse saprete i punti del piano sono infiniti, mentre per quanto possano essere piccoli e fitti i pixel di un'immagine essi sono in numero ben finito.
Se ipotizzo i pixel dell'immagine come una "discretizzazione" del piano complesso (passatemi questo brutto termine che a molti non piace), allora devo assegnare ad ogni pixel un certo punto del piano, fare i calcoli su quel punto, e colorare il pixel a seconda del risultato ottenuto.
Ora prendiamo il primo pixel dell'immagine, quello che sta in alto a sinistra per interci (perchè nelle immagini l'asse delle X va da sinistra a destra e quello delle Y dall'alto verso il basso), e diamogli come punto quello identificato dall'estremo inferiore per l'asse X e dall'estremo superiore per l'alle Y. Quando poi vogliamo passare al punto successivo (per ora considero lo spostamento solo sull'asse reale, cioè delle X) dovrò incrementare di una certa quantità.
Questa quantità che devo sommare per passare da un punto all'altro la posso calcolare sapendo quanto è lungo il lato reale che sto prendendo in cosiderazione (quindi estremo superiore di X - estremo inferirio di X) e va diviso per la larghezza dell'immagine (in pixel naturalmente). In questo modo per passare da un punto a l'altro si fa una semplice somma.
Notate che la stessa cosa va fatta/calcolta per l'asse delle Y, trovando la quantità di incremento dividendo il lato verticale del piano per il numero di pixel dell'altezza.

Poi ho bisongno del massimo numero di iterazioni da calcolare prima di considerare il punto come appartenente all'insieme. Ricordo che un punto viene considerato parte dell'insieme di Madelbrot e quindi colorato di nero, solo se dopo N iterazioni (con N numero massimo di iterazioni) del calcolo della successione, il valore rispetta ancora la legge.
Naturalmente avrò bisogno anche di altre variabili: per esempio dovrò poter memorizzare il valore di ogni punto del piano di cui sto calcolando la successione, il numero di iterazioni fatte per ogni punto calcolato, e intanto che ci siamo anche per quali indici/pixel/punto devo ancora continuare a calcolare la successione.
Le variabili definite a questo scopo sono:


  protected double infx = -2, supx = 2, infy = -2, supy = 2; //limiti del piano complesso su cui calcoare la successione
  protected double latox, latoy, incx, incy; //lunghezza dei lati e di quando devo incrementare il valore 
          //da un pixel e l'altro
  protected int maxIteration = 250; //numero massimo di iterazione

  protected Texture2D fractal; //texture
  protected bool complete = true; //indica se il calcolo è completo o no
  protected int width, height; //altezza e larghezza della texture
  protected Color[] pixData; //vettore contenente il colore dei pixel della texture
  protected int total; // numero totale dei pixel della texture

  protected Queue<int> indici = new Queue<int>(); //indice del pixel che devo calcolare
  protected int[,] iterazioni; //numero di iterazioni per ogni punto
  protected Cmplx[,] valori; //valore di ogni punto
  protected Cmplx zCm = new Cmplx(), cCm = new Cmplx(); //numeri complessi per il calcolo

NOTA: il perchè ho usato una queue (struttura dati che implementa una coda, cioè una "lista" di elementi con estrazione in testa testa ed inserimento in coda) sarà chiaro in seguito.

La classe MandelBrotFractal è figlia di GameComponent, in questo modo potrà avere il suo metodo update e eseguire parte del calcolo ad ogni chiamata del metodo. Inoltre implementerà un'interfaccia da me definita che esporrà i metodi per agire sul frattale.

public interface FractalI
{
  Texture2D Fractal { get; }
  void resizeTexture(int width, int height);
  bool Complete { get; }
  int Width { get; }
  int Heigth { get; }
  void UpdateFractalDouble(double infx, double supx, double infy, double supy, int MAX);
}

Il significato mi pare abbastanza esplicito, comunque quando si vedrà come vengono usati i metodi sarà ancora più chiaro.

Il codice completo della classe che genera il MandelBrot è questo:
Show/Hide


public class MandelBrotFractal : Microsoft.Xna.Framework.GameComponent, FractalI
{
    protected double infx = -2, supx = 2, infy = -2, supy = 2; //limiti del piano complesso su cui calcoare la successione
    protected double latox, latoy, incx, incy; //lunghezza dei lati e di quando devo incrementare il valore 
            //da un pixel e l'altro
    protected int maxIteration = 250; //numero massimo di iterazione

    protected Texture2D fractal; //texture
    protected bool complete = true; //indica se il calcolo è completo o no
    protected int width, height; //altezza e larghezza della texture
    protected Color[] pixData; //vettore contenente il colore dei pixel della texture
    protected int total; // numero totale dei pixel della texture

    protected Queue<int> indici = new Queue<int>(); //indice del pixel che devo calcolare
    protected int[,] iterazioni; //numero di iterazioni per ogni punto
    protected Cmplx[,] valori; //valore di ogni punto
    protected Cmplx zCm = new Cmplx(), cCm = new Cmplx(); //numeri complessi per il calcolo

    public MandelBrotFractal(Game game, double infx, double supx, double infy, double supy, int maxInt)
        : base(game)
    {
        //prendo i valori della larghezza e altezza della texture
        width = this.Game.GraphicsDevice.PresentationParameters.BackBufferWidth;
        height = this.Game.GraphicsDevice.PresentationParameters.BackBufferHeight;
        //numero totale di pixel
        total = width * height;
        pixData = new Color[total]; //creo l'array per i colori dei pixel

        //creo la texture
        fractal = new Texture2D(this.Game.GraphicsDevice,
            width,
            height, 1,
            TextureUsage.None, SurfaceFormat.Color);
        //creo la matrice che conterrà il numero di iterazioni fatte per ogni punto
        iterazioni = new int[height, width];
        //creo la matrice di numeri complessi che conterrà il valore di ogni punto del piano che sto calcolando
        //e di volta in volta il calcolo parziale
        valori = new Cmplx[height, width];
        for (int i = 0; i < height; i++)
            for (int j = 0; j < width; j++)
                valori[i, j] = new Cmplx();
    }

    public override void Initialize()
    {
        base.Initialize();
    }

    public override void Update(GameTime gameTime)
    {
        if (!complete)
        {
            //se il frattale è da completare eseguo il calcolo
            calcolaFrattale();
        }
        base.Update(gameTime);
    }

    protected virtual Cmplx calcola(Cmplx z, Cmplx c)
    {
        //calcolo il valore
        Cmplx ris = z.sqr().add(c);
        return ris;
    }

    protected Cmplx ris;

    private void calcolaFrattale()
    {
        //variabili usate per inizializzare c
        double cre, cim;

        int indice = 0;
        //memorizzo quanti indici devo calcolare
        int count = indici.Count;
        for(int i = 0; i < count; i++) //faccio count estrazioni dalla coda
        {
            indice = indici.Dequeue();
            //calcolo il corrispettivo indice di riga e di colonna
            int r = indice / width;
            int c = indice % width;
            //calcolo il valore di c da usare (potrei memorizzarlo in una matrice?)
            cre = infx + (c * incx);
            cim = infy + (r * incy);

            //recupero il valore di z
            zCm = valori[r, c];
            //controllo che il valore sia in modulo minore di 4 e che non abbia già fatto il max num di iterazioni
            if (zCm.modsq() <= 4 && iterazioni[r, c] < maxIteration)
            {
                cCm.set(cre, cim);
                ris = calcola(zCm, cCm); //eseguo il calcolo
                valori[r, c] = ris; //aggiorno
                iterazioni[r, c]++; //aggiorno
                indici.Enqueue(indice); //reinserisco l'indice nella coda per il prossimo calcolo
            }
            else
            {
                if (iterazioni[r, c] == maxIteration)
                {
                    //il punto fa parte dell'insieme: lo coloro di nero
                    pixData[indice] = Color.Black;
                }
                else
                {
                    //il punto non fa parte dell'insieme
                    float val = (float)iterazioni[r, c] / maxIteration;
                    int h, s, v;
                    HsvToRgb(360.0f * val, 1.0f, 1.0f, out h, out s, out v);
                    //lo coloro in modo opportuno
                    pixData[indice] = new Color((Byte)h, (Byte)s, (Byte)v);

                    //Nota: cambiando come si calcola il colore posso ottenere scale di colore diverse
                }
            }
        }
        try
        {
            fractal.SetData(pixData);//aggiorno la texture
        }
        catch (Exception e)
        { }
        if (indici.Count == 0)
        {
            //se la coda risulta vuota vuol dire che ho finito di calcolare
            this.Game.Window.Title = "Render complete";
            complete = true;
        }
    }

    private Color makeColor(float r, float g, float b)
    {
        System.Drawing.Color color = System.Drawing.Color.FromArgb((int)(r), (int)(g), (int)(b));
        return new Color(color.R, color.G, color.B);
    }

//qui c'è la funzione per il passaggio dal HSV a RGB
//guardate i sorgenti

    int Clamp(int i)
    {
        if (i < 0) return 0;
        if (i > 255) return 255;
        return i;
    }

    #region FracalI Membri di

    public Texture2D Fractal
    {
        get { return fractal; }
    }

    /// <summary>
    /// aggiorna il calcolo del frattale dando gli estremi del piano su cui calcolare e il massimo numero di iterazioni
    /// </summary>
    /// <param name="infx"></param>
    /// <param name="supx"></param>
    /// <param name="infy"></param>
    /// <param name="supy"></param>
    /// <param name="maxIt"></param>
    public virtual void UpdateFractalDouble(double infx, double supx, double infy, double supy, int maxIt)
    {
        this.infx = infx;
        this.supx = supx;
        this.infy = infy;
        this.supy = supy;
        this.maxIteration = maxIt;

        latox = Math.Abs(supx - infx);
        latoy = Math.Abs(supy - infy);
        incx = latox / width;
        incy = latoy / height;

        this.Game.Window.Title = "Render WIP";
        complete = false;
        indici.Clear();
        for (int i = 0; i < total; i++)
        {
            int r = i / width;
            int c = i % width;
            indici.Enqueue(i);
            iterazioni[r, c] = 0;
            valori[r, c].set(0, 0);
            pixData[i] = Color.Lerp(pixData[i], Color.Black, 0.7f);
        }
        fractal.SetData(pixData);
    }

    public bool Complete
    {
        get { return complete; }
    }

    public int Width
    {
        get { return width; }
    }

    public int Heigth
    {
        get { return height; }
    }

    /// <summary>
    /// ridimenziona la texture su cui andiamo a calcolare il frattale
    /// </summary>
    /// <param name="width"></param>
    /// <param name="height"></param>
    public void resizeTexture(int width, int height)
    {
        //aggiorna i valori
        this.width = width;
        this.height = height;

        total = width * height;
        //ricrea il vettore dei colori
        pixData = new Color[total];

        //elimina la vecchia texture e la ricrea
        fractal.Dispose();
        fractal = new Texture2D(this.Game.GraphicsDevice,
            width,
            height, 1,
            TextureUsage.None, SurfaceFormat.Color);

        //ricrea la matrice con il numero di iterazioni fatte per ogni punto
        iterazioni = new int[height, width];
        //ricrea la matrice di numeri complessi per memorizzare il valore di ogni punto
        valori = new Cmplx[width, height];
        for (int i = 0; i < width; i++)
            for (int j = 0; j < height; j++)
                valori[i, j] = new Cmplx();

        //forzo l'aggiornamento
        UpdateFractalDouble(infx, supx, infy, supy, maxIteration);
    }

    #endregion
}

Preferisco soffermarmi sul metodo calcolaFrattale() e su quello che fa:
quello che facciamo è controllare quanti elementi sono presenti nella coda degli indici (punti) per cu idevo calcolare il prossimo passo della successione (in questo modo so quante estrazioni fare).
Quindi comincio con estrarre l'elemento in testa alla coda, e calcolati l'indice di riga e di colonna trovo il valore della costante C da usare nel calcolo della successione per quel punto.
Il valore di C cambia a seconda del punto che stiamo considerando.
Poi recuperiamo il valore precedente per Z, e controlliamo se in modulo è minore di 4, o se non abbiamo già eseguito per il quel punto il massimo numero di iterazioni.
Se il punto ha valore in modulo maggiore di 4 non fa parte dell'insieme, quindi va colorato in modo oppurtuno. Se invece ho fatto il massimo numero di iterazioni e il valore del punto è ancora minore di 4 lo considero come appartenente all'insieme di Madelbrot e lo coloro di nero.
Per la colorazione del punto, uso il rapporto tra il numero di iterazioni fatte prima di trovare che il punto diverge e il numero massimo di iterazioni come parametro nella funzione che trasforma un colore in scala HSV in RGB (dove il rapporto è usato come H, cioè Hue, cioè la tonalità del colore).
Cambiando il modo in cui si usa il numero di iterazioni fatte nel calcolo del colore del pixel possono ottenere scale di colore diverse.

Come potete vedere osservando il codice, ogni volta che eseguiamo il metodo calcolaFrattale, viene calcolato un passo per ogni punto che ancora non è stato considerato non appartenente all'insieme. Questo vuol dire che mano a mano che si procede nel calcolo avrò sempre meno punti su cui calcolare la successione, e quindi il calcolo tenderà a diventare più veloce!

NOTA: perchè per ogni esecuzione del metodo calcolo un solo passo? Non posso calcolare tutto il frattale in una volta sola?
Certo si poteva fare anche in quel modo, ma poi non avrei potuto renderizzare lo stato intermedio del calcolo: in parole semplici avrei dovuto aspettare che il calcolo fosse concluso per poter far vedere il frattale, mentre in questo modo lo posso renderizzare anche quando è in fase di costruzione. In questo modo l'attesa per la completazione del frattale sarà più sopportabile ^^

Diamo adesso una piccola spiegazione sull'implementazione del metodo UpdateFractal():
questo metodo non fa altro che aggiornare lo stato del componente con i valori passati, e fa ripartire il cacolo del frattale con i nuovi dati.
Adesso io volevo (ed ho poi fatto) un effetto di transizione tra un'immagine di un fratale e quella successiva, solo che non "sapevo" dove metterla e alla fine l'ho messa in questo metodo.
Analizziamo in dettaglio ciò:


           for (int i = 0; i < total; i++)
           {
               int r = i / width;
               int c = i % width;
               indici.Enqueue(i);
               iterazioni[r, c] = 0;
               valori[r, c].set(0, 0);
               pixData[i] = Color.Lerp(pixData[i], Color.Black, 0.7f);
           }

in questo pezzo di codice scorro il vettore che contiene il colore di ogni pixel dell'immagine. All'inizio impostavo tutti i pixel a nero, solo che così il passaggio tra un'immagine e la successiva era troppo netta (almeno per i miei gusti), e la cancellazione istantanea dell'immagine mi dava noia.
Quindi ho deciso di scurire tutta l'immagine facendo una semplice interpolazione tra il colore attuale de pixel ed il colore nero. Successivamente, quando il calcolo del frattale verrà riavviato, si andrà a lavorare di nuovo sulla stessa texture, colorando in modo diverso i pixel. Si avrà quindi un effetto di transizione tra un'immagine e l'altra.

Spero di essere stato chiaro fino ad ora, dato che adesso viene la parte più incasinata, e cioè gestire ed agire sul frattale tramite gli strumenti offerti da XNA.
Quello che voglio fare è riuscire, con il mouse, a selezionare una zona del frattale su cui fare zoom, quindi modificare gli estremi della zona del piano su cui stiamo calcolando la successione.
Voglio poi poter incrementare e drecrementare il numero massimo di iterazioni da fare come la risoluzione della texture su cui calcolo il frattale (più pixel ho più punti dovrò considerare, quindi avrò una maggiore precisione).

Invece di stare a schiaffarvi qui il codice dell'applicazione ve lo lascio la leggere direttamente dal sorgente, dato che la cosa che mi ero proposto di fare era spiegarvi come avevo implementanto il calcolo del frattale.
Però il codice sarà abbastanza commentanto, in questo modo non dovreste avere difficoltà!

Ecco il link al file
XNA-Mandelbrot.rar

Spero di essere stato il più chiaro possibile...
in caso non lo sia stato (cosa più che probabile XD) non esitate a chidere chiarimenti, a dirmi dove ho sbagliato, o anche a mandarmi a quel paese se volete!

Ciauz! Alla prossima da Odino!

XNA - Frattali

2009-10-26T22:50:00.001+01:00

Tutto ciò è colpa di un mio professore dell'università...
E' lui che ha fatto accadere tutto ciò ?_?
Non ve la prendete con me ?_?

Seguendo il corso di Costruzione di Interfacce il nostro professore ci ha fatto vedere un'applicazione che fatto lui: si tratta di un programma che permette di calcolare e visualizzare il frattale di Mandelbrot.
Il frattale di MandelBrot è uno dei più famosi frattali (lo so dire ora, ma prima che ce lo facesse vedere lui manco sapevo chi fosse XD), e devo dire che con i frattali ci si può "divertire". Tutto ciò mi ha fatto tornare alla mente quando, da piccolo, mio padre mi fece vedere un programma per calcolare queste strane immagini, dove io potevo selezionare una parte piccola piccola, e l'immagine non "perdeva di dettaglio"... Ah beata innocenza XD

Sta di fatto che dopo aver visto questo programma fatto dal nostro professore mi sono deciso a farne uno mio. Dato che sto lavorando con XNA ho deciso di farne uno che utilizzasse XNA per calcolare e visualizzare i frattali.
Ci sto ancora lavorando, e devo implementare alcuni particolari, ma direi che il grosso è fatto.
Quindi se vi chiedete che fine ho fatto, o sono dentro un frattale(XD) o sto studiando per un esame (che voglia eh XD).

Intanto vi lascio con qualche immagine ottenuta da questo generatore di frattali che ho fatto ^_^
Spero vi piacciano :)
Quando sarà finito posterò qualcosa del codice che ho fatto!

A presto :)

The Xna-Way: Tutorial 8: Screen Shots del nostro gioco!

2009-10-22T11:30:00.001+02:00

Aggiornamento al 16/04/2011:
con l'aggiornamento alla versione 4 di Xna questo codice non è più funzionante, dato che alcune delle classi ed oggetti che vengono utilizzate sono state eliminate o è stato rivisto il loro funzionamento.

Quale è una cosa di cui oggi come oggi non si può fare a meno in un videogame?
Bè una delle tante è la possiibilità di salvare la schermata di gioco, di farne una foto e di conservarla, in modo da mostrare ai nostri cari amici (nerd anche loro come noi) le nostre peripezie XD
Questa cosa oltre ad essere una chicca che oramai cerchiamo in quasi ogni gioco mi tornerà utile anche per catturare schermate di gioco per i piccoli tutorial che farò.

Mi sono quindi messo di buzzo buono, e studiando degli esempi che ho trovato su Xna-club, esempi che tra l'altro trattavano effetti di post processing come bloom, e ho tirato fuori il mio piccolo componente.

L'idea su cui mi sono basato è questa: XNA ci fornisce un ciclo di esecuzione nel quale vengono invocati in continuazione i metodi Update e Draw dei components che fanno parte del nostro gioco.
Ora uno screen shot va salvato quando la scena è stata completamtente renderizzata. Quindi, ragionevolmente, dovremmo salvarla dopo che sono stati eseguiti tutti i metodi Draw dei nostri componenti.
Ma come possiamo essere sicuri o controllare questa cosa?

La cosa più semplice ed immediata da fare è capire che la scena che noi vogliamo salvare, è "completa" quando siamo nel metodo update. Cioè saremo "indietro" di un frame quando andremo a salvare l'immagine, gli oggetti non saranno stati spostati, ma nel contempo il rendering della scena non sarà ancora incominciato, e quindi avremo (da qualche parte in memoria) il render completo della scena al frame precedente!
Quello che dobbiamo fare è semplicemtente recuperarlo e salvarlo.

Ecco la classe, il component, che fa questo:
Show/Hide


    public class ScreenShots : Microsoft.Xna.Framework.GameComponent
    {
        ResolveTexture2D resolveTarget;
        string path;
        InputI inputDevice;

        public ScreenShots(Game game)
            : this(game, System.Environment.GetFolderPath(System.Environment.SpecialFolder.MyPictures))
        {
        }

        public ScreenShots(Game game, string path)
            : base(game)
        {
            this.path = path;
            inputDevice = (InputI)game.Services.GetService(typeof(InputI));
        }

        public override void Initialize()
        {
            PresentationParameters pp = Game.GraphicsDevice.PresentationParameters;
            SurfaceFormat format = pp.BackBufferFormat;
            resolveTarget = new ResolveTexture2D(Game.GraphicsDevice, pp.BackBufferWidth, pp.BackBufferHeight, 1,
                format);
            base.Initialize();
        }

        public override void Update(GameTime gameTime)
        {
            if (inputDevice.wasPressed(Keys.PrintScreen))
            {
                Game.GraphicsDevice.ResolveBackBuffer(resolveTarget);
                DateTime time = DateTime.Now;
                try
                {
                    ((Texture2D)resolveTarget).Save(path + @"\screen" + time.Ticks.ToString() + ".jpg", ImageFileFormat.Jpg);
                }
                catch (Exception e)
                {
                }
            }
            base.Update(gameTime);
        }

Al costruttore gli viene passato il percorso della directory in cui salvare le immagini, oppure solo il riferimento alla Game, ed in questo secondo caso la directory di default per il salvataggio delle immagini è la cartella immagini dell'utente.
Come si vede si recupera anche il riferimento al servizio per l'input.

In Initialize creo un ResolveTexture2D delle stesse dimensioni e formato del backBuffer del gioco.

Nel metodo update controlliamo se il tasto Stamp (o printScree, dipende da come lo si vuole chiamare) è stato premuto.
In caso positivo tramite ResolveBackBuffer recupero il backBuffer del frame precedente (e quindi il render completo della scena precente) e lo metto in resolveTarget.
Dato che resolve target è un tipo particolare di Texture2D posso forzare con un cast il suo tipo ad essere Texture2D appunto, ed usare quindi il metodo save per salvare su disco l'immagine.

Tutto qua. Così possiamo salvare semplicemente gli screen del nostro gioco.

Nel costruttore di Game1 si deve aggiungere le seguenti righe:


            screenShot = new ScreenShots(this);
            Components.Add(screenShot);

ed siamo veramente alla fine!

Non allego questa volta il file con il codice, dato che la classe è piccola e completamente inserita nel post.

Spero vi sia utile.
Alla prossima!

The Xna-Way: Tutorial 7: Collisioni con BoundingSphere

2009-10-17T11:44:00.002+02:00

Dopo molto, troppo, tempo eccomi di nuovo qua a parlare di qualcosa inerente ad XNA.
Questa volta voglio un po' parla delle collisioni, cosa che fa impazzire ogni programmatore di Video Giochi.

Anche io sono impazzito (più di quanto non fossi prima) quando mi sono addentrato in questo campo, e devo dire che ne sono rimasto un po' spaventato.

Come si possono calcolare oggi come oggi le collisioni tra 2 oggetti?
Bè un esempio di ciò l'ho usato per calcolare quali oggetti erano intersecati dal bounding Frustum della telecamera e quindi filtrare quelli da renderizzare da quelli che non lo erano.
Questo è un esempio di collisioni fatto con i VOLUMI: ho usato un sfera (per la precisione una BoundingSphere) per approssimare il volume degli oggetti presenti nella scena (ci dovrà essere una sfera per ogni oggetto, o nel caso di oggetti replicati una sola sfera che verrà riposizionata e aggiornata per ogni oggetto di cui voglio calcolare la collisione).
Come qualcuno potrà pensare, calcolare le collisione di 2 oggetti approssimando il loro volume con delle sfere può portare a delle approssimazioni tali da avere un grosso grado di imprecisione del calcolare l'effettiva collisione tra due oggetti.
Se il nostro oggetto è una sfera allora la sua BS (abbreviazione di BoundigSphere) coinciderà esattamente con l'oggetto, ma già nel caso di un cubo esso verrà contenuto per intero all'interno della sfera, così con oggetti più complessi!
Ecco un esempio di quando ho detto:

Come possiamo vedere la navicella e il meteorite sono completamente contenuti all'interno delle loro sfere, anche se buona parte delle sfere non sono occupate dal volume del modello.

Come si fa per calcolare le collissioni? La collisione viene calcolata controllando se le due sfere si toccano o si intersecano l'una con l'altra. Ho una collisione anche se una sfera è contenuta interamente in un'altra.

XNA ci offre la classe BoundingSphere la quale è caratterizzata da una posizione e da un raggio. Le BS sono comode perchè anche se muoviamo o ruotiamo l'oggetto esso sarà sempre contenuto all'interno della stessa sfera, cosa che non accade con i BoundingBox (altro tipo di volumi per approssimazione), i quali sono dei parallelepipedi. Nel caso di una rotazione dobbiamo ricalcolare il rettangolo che contiene il nostro modello.
L'unico caso in cui dobbiamo modificare la sfera è quando scaliamo il nostro oggetto, dato che dovremo anche aumentare/diminuire il raggio della sfera.

In tutto questo tempo ho cercato a giro metodi "semplici" per il calcolo della collisione tra due oggetti nel modo più preciso possibile, cioè del tipo poligono contro poligono, vertice su poligono, etc, ma come potete immagianare con scarsi risultati.
Ho provato a farne uno di mio, ma non funzionava bene ed il calcolo era talmente peso che già per modelli a basso numero di poligoni il frame rate si abbassava enormemente.
Ho decico quindi per ora di dedicarmi a qualcosa di meno complicato e di continuare a scrivere qualcosa. Poi quando avrò maggiori conoscenze continuerò in seguito ad approfondire questo argomento.

Quello che mi sono proposto di fare è quanto segue: alla creazione del modello ho deciso di estrarre dalle informazioni la boundingSphere caricata, e di tenerla aggiornata secondo le trasformazioni dell'oggetto. Esporrò poi un metodo per permettere di controllare se due dati modelli stanno collidendo con le boundingSphere. Forse non è proprio il caso di utilizzare una classe, ma utilizzare un'interfaccia che esponga queste proprietà comuni agli oggetti di cui vogliamo controllare le collisioni.

Quello che ho fatto è stato definire la seguente interfaccia:


public interface CollisionI
{
   BoundingSphere _BoundingSphere { get; }
   bool CheckSPhereCollision(CollisionI obj);
}

Questa interfaccia contiene una proprietà e un metodo: la proprietà ritorna la boundingSphere relativa all'oggetto, mentre il metodo controlla se per due oggetti che implementano l'interfaccia ci sia o meno collisione.
Da notare che in questo modo non vincolo il tipo degli oggetti tra cui posso calcolare la collisione, basta che implementino l'interfaccia e posso calcoare tutto.
Certo è un poco spoglia, ma nessuno ci vieta in futuro, quando ne avremo bisogno, di aggiungere nuove funzionalità a questa interfaccia (aggiornando poi naturamente le classi che le implementano).
Ho deciso di utilizzare un'interfaccia anche per dare libera scelta di implementare in modo diverso le funzionalità da una classe all'altra.

Vediamo le modifiche fatte nella classe Ship:
Codice da aggiungere a livello di classe->


       //dati per le collisioni
       BoundingSphere sphere;
       float radius;
       public Color colore = Color.Yellow;
       public BoundingSphere _BoundingSphere
       {
           get { return sphere; }
       }

       public bool CheckSPhereCollision(CollisionI obj)
       {
           return sphere.Intersects(obj._BoundingSphere);
       }

Codice da aggiungere nel costruttore->


           sphere = new BoundingSphere();

           foreach (ModelMesh mesh in this.myModel.Meshes)
           {
               foreach (ModelMeshPart mp in mesh.MeshParts)
                   mp.Effect = currentEffect;
               sphere = BoundingSphere.CreateMerged(sphere, mesh.BoundingSphere);
           }
           radius = sphere.Radius;

Codice da aggiungere nel metodo update (in fondo prima di base.Update(gameTime);)->


           sphere.Center = position;
           sphere.Radius = radius * scale;

OK!
In questo modo abbiamo aggiunto nella classe i campi necessari a gestire le boundingSphere, abbiamo implementato i metodi richiesti.
Nel costruttore creaiamo la boundingSphere come la sfera più grande che può contente tutte le boundingSphere di ogni singola parte del nostro modello (per ora non mi interessa di calcolare possibili sottocollisioni con le singole parti del modello, mi accontento di un calcolo più grossolano, se volete specializzare fate voi, io mi per ora mi accontento di capire il concetto ^^).
Mi salvo anche il raggio iniziale delle sfera.
Nel metodo update riposiziono la sfera in base alla posizione del modello e riaggiorno il raggio (nel caso sia stato scalato il modello).

Come faccio a disegnare la sfera e a farla visualizzare?
Ho usato una classe statica trovata qua:
Rendering Bounding Spheres
Passando al metodo render la sfera (più altri parametri) essa sarà renderizzata per noi. Certo è un po' pesante quando si deve disegnare molte sfere, quindi non esageriamo! (o se proprio volete renderizzare tutte le sfere vi consiglio di abbassare la risoluzione delle stesse: nel metodo render della classe statica andate a cambiare il valore 30 presente nella chiamata a InitializeGraphics da a 0, le sfere saranno leggermente più spigolose ma ne guadagnarete in prestazioni!).
Quindi nel metodo draw della nostra classe Ship, dopo che abbiamo disegnato il modello aggiungete la seguente riga:
BoundingSphereRenderer.Render(sphere, this.Game.GraphicsDevice, myCamera.View, myCamera.Projection, Color.Yellow);

Ora se lanciate il gioco dovreste vedere una sfera approssimata da due cerchi, di colore giallo.

Ora c'è da fare delle modifiche alla classe MeteorManager:
Codice da aggiungere a livello di classe->


       BoundingSphere sphere;
       float radius;

       public BoundingSphere _BoundingSphere
       {
           get { throw new NotImplementedException(); }
       }

       public bool CheckSPhereCollision(CollisionI obj)
       {
           int val = 1;
           for (int i = (cameraR - val); i <= this.cameraR + val; i++)
           {
               for (int j = (this.cameraC - val); j <= this.cameraC + val; j++)
               {
                   for (int k = (this.cameraP - val); k <= this.cameraP + val; k++)
                   {
                       int r = i % cells;
                       int c = j % cells;
                       int p = k % cells;
                       if (r < 0)
                           r = cells + r;
                       if (c < 0)
                           c = cells + c;
                       if (p < 0)
                           p = cells + p;
                       foreach (Trasformation tras in gameWorld[r % cells, c % cells, p % cells].myList)
                       {
                           sphere.Center = tras.position;
                           sphere.Radius = radius * tras.scale;
                           if (sphere.Intersects(obj._BoundingSphere))
                               return true;
                       }
                   }
               }
           }
           return false;
       }

Cosa fa il metodo CheckSPhereCollision?
Prende l'indice della cella in cui siamo, scorre le celle adiacenti a noi, e controlla (riposizionando la sfera e riscalandola) se c'è una collisione con uno degli elementi. Se ne trova uno con cui ho collisione ritorna true, altrimenti se dopo aver controllato tutti gli elementi possibili non ho trovato nessuna collisione ritorno false.

Il costruttore va modificato con le stesse righe aggiunte nel costruttore di Ship.
Il metodo update non va cambiato, dato che per ora i nostri meteoriti devono star fermi.
Andiamo al metodo draw: questa riga va aggiunta nel ramo più interno, all'interno del IF che fa la verifica se la sfera è o meno intersecata dal frustum della telecamera->
BoundingSphereRenderer.Render(sphere, this.Game.GraphicsDevice, myCamera.View, myCamera.Projection, Color.Purple);

Da notare che ora la sphere a cui faccio riferimento non è più quella creata localmente nel Draw, ma quella a livello di classe. In questo modo non andremo a creare un nuovo oggetto ogni volta che viene eseguito il metodo Draw, con un miglioramento dell'utilizzo della memoria direi (su pc non si noterà, ma credo che sulla 360 forse si...).

Per rendere le cose un po' più "carine" ho deciso di fare ciò:
- nel metodo draw del MeteorManager ho diminuito la variabile val a 5
- nel LoadContent di Game1 ho portato il numero di meteoriti per cella da 5 a 3 (per alleggerire il calcolo)
-nella classe Ship ho aggiunto:
public Color colore = Color.Yellow;
-> nel metodo Update di Game1 ho aggiunto:


            if (mman.CheckSPhereCollision(myShip))
                myShip.colore = Color.Red;
            else
                myShip.colore = Color.Yellow;

In questo modo quando si rileva una collisione il colore della sfera della nostra nave diverrà rosso, mentre tornerà giallo quando non collidiamo con nulla!

Dovrebbe essere tutto! :D
Se qualcosa non va c'è sempre il file allegato!
E se trovate qualche errore fatemelo notare così correggo ^__^

XNA-tut7.rar

Argomenti trattati:
> Collisioni con BoundingSphere

Se leggete o scaricate i sorgenti lasciate un commento plz, almeno mi rendo conto di come vanno le cose ^^

Alla prossima!

The Xna-Way: Tutorial 6: Orientare oggetto nella direzione in cui si muove e telecamera che lo insegue

2009-09-11T10:00:00.000+02:00

Questa volta il compito che mi sono proposto è stato un po' più difficile:
avendo creato un decente MeteorManager questa volta volevo muovermi attraverso questo fitto campo di meteoriti con una navicella spaziale.

Sono partito col pensare a ciò:
- per ora non mi interessa calcolare le collisioni con i meteoriti
- la telecamera sarà in 3° persona, quindi ci troveremo alle spalle della nostra astronave (altrimenti avevamo già la telecamera in prima persona per muoverci)
- la telecamera dovrà seguire il nostro vascello spaziale
- dovremo far muovere nello spazio il nostro mezzo di trasporto

tutto questo ci porta a dover modificare la nostra telecamera per implementare "l'inseguimento" della nostra astronave. Avremo quella che chiamo Follow Camera.
Anche per il nostro vascello avremo il nostro bel da fare: non dovremmo solo farlo muovere e ruotare nel mondo 3D, ma dovremo farlo muovere nella direzione in cui "guarda", quindi movimenti e rotazioni dovranno essere fatti in modo particolare lavorando sulle direzioni, cosa un po' complicata e astrusa ma fattibile.

Per prima cosa è meglio fare la modifica alla classe Camera in modo da implementare l'inseguimento di un determinato bersaglio. In questo modo quando poi andremo a far muovere il nostro oggetto nello spazio la telecamera gli starà dietro e noi non avremo problemi ad osservarlo ^_^

Preso il progetto dell'ultimo post, andiamo nella classe Camesa.cs e sotto il metodo UpdateFreeCamera() andiamo a mettere il seguente metodo:


       private void updateFollowCamera(GameTime gameTime)
       {
           float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
           //creo la matrice temporanea
           Matrix tmp = Matrix.Identity;
           //imposto la direzione di osservazione, la direzione dell'alto e la direzione della destra
           tmp.Forward = direction;
           tmp.Up = up;
           tmp.Right = Vector3.Cross(up, direction); //questa è calcolata come prodotto tra due vettori

           Vector3 t;
           //trasformo la distanza (offset) dal punto di osservazione con la matrice calcolata
           Vector3.Transform(ref offset, ref tmp, out t);

           Vector3 positionTmp;
           //calcolo la posizione che vogliamo far avere alla nostra telecamera sommando al punto che siamo osservando
           //la posizione trasformata lungo la matrice
           Vector3.Add(ref target, ref t, out positionTmp);
           //aggiorno la posizione finale
           position = positionTmp;
       }

Per non avere errori dovremo aggiungere le seguenti variabili di classe:


       //variabili per l'inseguimento del target
       protected Vector3 offset = Vector3.Zero;
       protected Vector3 direction = Vector3.Forward

Cosa fa il metodo?
Il metodo crea una matrice identità e ne imposta i valori per le direzioni che rappresentano il davanti, l'alto e la destra.
Direction e up da dove vengono? Sono dati e assegnati tramite l'oggetto che vogliamo inseguire: cioè direction rappresenta la direzione in cui si sta muoveno il nostro oggetto, mentre up è la direzione che il nostro bersaglio considera come l'alto. In questo modo potremmo mantenere costati le rotazioni!
La destra viene calcolata come prodotto tra i due vettori.

Dopo trasformo l'offest usando la matrice, e sommo questo offest alla posizione del punto osservato e assegno il risultato alla posizione.

Quello che manca da fare ora è la classe per gestire la nostra navicella spaziale.
Ecco il file Ship.cs, comunque presente nell'archivio allegato:
Ship.cs Show/Hide


   public class Ship : Microsoft.Xna.Framework.GameComponent
   {
       Model myModel;
       Matrix world;
       InputI inputDevice;
       CameraI myCamera;

       //Dati per il rendering
       Texture2D text;   

       Effect currentEffect = null;
       public Effect CurrentEffect
       {
           get { return currentEffect; }
           set { currentEffect = value; }
       }

       //Dati per le trasformazioni
       Vector3 position = Vector3.Zero;
       public Vector3 Position
       {
           get { return position; }
           set { position = value; }
       }

       float scale = 1.0f;
       public float Scale
       {
           get { return scale; }
           set { scale = value; }
       }

       //Dati per l'orientamento verso la direzione di movimento
       Vector3 destra = Vector3.Right;
       Vector3 up = Vector3.Up;
       public Vector3 Up
       { get { return up; } }

       Vector3 direction = Vector3.Forward;
       public Vector3 Direction
       { get { return direction; } }

       float pitch, yaw;
       float val;
       Vector3 velocità;

       public Ship(Game game, string myModel, string texture, Effect effect)
           : base(game)
       {
           this.myModel = Game.Content.Load<Model>(myModel);
           this.text = Game.Content.Load<Texture2D>(texture);
           myCamera = (CameraI)game.Services.GetService(typeof(CameraI));
           inputDevice = (InputI)game.Services.GetService(typeof(InputI));
           currentEffect = effect;

           foreach (ModelMesh mesh in this.myModel.Meshes)
               foreach (ModelMeshPart mp in mesh.MeshParts)
                   mp.Effect = currentEffect;
       }

       public override void Initialize()
       {
           base.Initialize();
       }

       public override void Update(GameTime gameTime)
       {
           float elaps = (float)gameTime.ElapsedRealTime.TotalSeconds;
           yaw = 0;
           pitch = 0;
           val = 0;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Space))
               val = 1.0f;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
               yaw -= 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
               yaw += 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
               pitch -= 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
               pitch += 3f * elaps;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.R))
           {
               yaw = 0.0f;
               pitch = 0.0f;
               direction = Vector3.Forward;
               up = Vector3.Up;
               destra = Vector3.Right;
               position = Vector3.Zero;
           }

           //se l'astronave a testa in giù devo invertire il valore di yaw
           if (up.Y < 0)
               yaw = -yaw;

           //calcolo la matrice di rotazione data dagli angoli yaw e pitch
           Matrix rotationMatrix = Matrix.CreateFromAxisAngle(destra, pitch) *
               Matrix.CreateRotationY(yaw);

           //trasformo la direzione e l'alto con la matrice calcolata
           Vector3.TransformNormal(ref direction, ref rotationMatrix, out direction);
           Vector3.TransformNormal(ref up, ref rotationMatrix, out up);

           //normalizzo
           direction.Normalize();
           up.Normalize();

           //calcolo i vettori destra e up come prodotto tra vettori
           Vector3.Cross(ref direction, ref up, out destra);
           Vector3.Cross(ref destra, ref direction, out up);

           //calcolo la forza, l'accellerazione e la velocità
           Vector3 forza = direction * val * 2400000;
           Vector3 accellerazione = forza / 2 ;
           velocità = accellerazione * elaps;
           /*
            //ricorda di diminuire il fatto moltiplicativo nel cacolo della forza
            velocità += accellerazione * elaps;

            //per farlo fermare nel caso si usasse il secondo metodo
            velocità *= 0.97f;*/

           position += velocità * elaps;

           //----------------------------------
           world = Matrix.Identity;

           world.Forward = direction;
           world.Up = up;
           world.Right = destra;

           world *= Matrix.CreateScale(scale);
           world *= Matrix.CreateTranslation(position);
          
           base.Update(gameTime);
       }

       public void Draw(GameTime gameTime)
       {
           currentEffect.Parameters["Color"].SetValue(Color.White.ToVector4());
           currentEffect.Parameters["Projection"].SetValue(myCamera.Projection);
           currentEffect.Parameters["View"].SetValue(myCamera.View);
           currentEffect.Parameters["ColorMap"].SetValue(text);
           currentEffect.Parameters["World"].SetValue(world);
           foreach (ModelMesh mesh in myModel.Meshes)
               mesh.Draw();
       }
   }

Il file va inserito nel progetto Meteor e non nella libreria, dato che, come il MeteorManager, questo oggetto è specifico per questa applicazione.

Il pezzo saliente è il metodo Update, il resto è roba già vista!
Cosa fa questo benedetto metodo?
Prima di tutto riazzera il valore della rotazione per yaw e pitch, e anche val.
Val indica se la barra spaziatrice è premuta o meno, e quindi se dobbiamo muoverci o no.
Con la pressione delle frecce direzionali imposto i valori per le rotazioni, e con R riporto il tutto allo stato iniziale.

Con


if (up.Y < 0)
    yaw = -yaw;

faccio in modo che se mi trovo a testa in giù e premo verso destra, continuo a girare ancora verso destra non verso sinitra.

Dopo di chè calcolola matrice di rotazione (nota: l'angolo per pitch è calcolato passando l'asse di rotazione), e uso tale matrice per trasformare la direzione e l'up.

Ho poi il calcolo della forza applicata all'oggeto.
Sono formule fisiche. Forza = massa * accellerazione.
So che la formula per calcolare la velocità è sbagliata (anche se quella giusta è riportata come commentata). Ma ora come ora non mi interessa la correttezza delle fisica.

Alla fine poi ho la creazione della world matrix per la nostra navicella, fatta in modo molto simile a come abbiamo costruito quella per la telecamera.

Cosa manca da fare per far funzionare il tutto?
Aggiungere il file per il modello 3D e la texture al progetto, creare la nostra astronave, aggiungerla ai components e disegnarla.
Poi dobbiamo modificare leggermente le impostazioni della telecamera.

Cominciamo: nel costruttore di Game1.cs modifichiamo il codice per la telecamera come segue


           myCamera = new Camera(this);
           myCamera.FarPlane = 100000;
           myCamera.Offset = new Vector3(0, 100, 500);
           myCamera.Mode = CameraMode.Follow;
           Components.Add(myCamera);

Impostiamo la distanza dal punto di osservazione e cambiamo il tipo di telecamera.

Nel metodo LoadContent() aggiungiamo questo:


           myShip = new Ship(this, @"Models\p2_wedge", @"Textures\wedge_p2_diff_v1", defaultEffect);
           myShip.Scale = 0.1f;
           Components.Add(myShip);

Dove myShip è l'oggetto per la nostra astronave, che dobbiamo aver definito nella classe. Lo scalo ad un fattore 0.1 perchè altrimenti sarebbe troppo grande.

Nel metodo Draw dopo il render per il meteorManager aggiungiamo questo:
myShip.Draw(gameTime);

E nel metodo Update questo:


           if (myCamera.Mode == CameraMode.Follow)
           {
               myCamera.Target = myShip.Position;
               myCamera.Up = myShip.Up;
               myCamera.Direction = myShip.Direction;
           }

In modo che se la telecamera è di tipo follow, si aggiorna il suo target alla posizione della nostra navicella (ma potrebbe essere benissimo qualsiasi cosa!), e settiamo up e direction con i valori provenienti dal nostro oggetto myShip.

Dovrebbe essere tutto! :D
Se qualcosa non va c'è sempre il file allegato!
E se trovate qualche errore fatemelo notare così correggo ^__^

XNA-tut6.rar

Argomenti trattati:
> muovere un oggetto lungo la direzione che sta osservando
> telecamera che insegue il nostro oggetto

Alla prossima!

The Xna-Way: Tutorial 5: Meteor Manager & Free Camera

2009-09-09T15:00:00.000+02:00

Eccomi dopo un po' di tempo con un altro post sull'XNA e un suo utilizzo.

Questa volta mi sono detto: "voglio avere una scena con tanti, ma tanti oggetti!"
Ah, quando il masochismo non ha limiti...
Qualcosa ho comunque fatto, anche se non è proprio un granchè...

Quello che mi è venuto in mente, in modo da poterlo poi riusare anche in futuro per una qualche demo simile ad un Asteroid, è di avere un gestore di meteoriti!
Cioè questo gestore ci deve la possibilità di renderizzare a schermo tanti meteoriti.
E vogliamo pure dare la possibilità di muoversi in questo mondo no?
Quindi dovremo fare delle modifiche alla telecamera, in modo che ci pemetta di spostarci in questo universo popolato unicamente da meteoriti!

Allora per il metorManager creremo un file in un progetto per un gameWindows a se stante, mentre il file della della telecamera che andremo a modifcare è sempre quello della myLibrary.

Prima di tutto vediamo come strutturare questo fantomatico MeteorManager. Io l'ho pensato in questo modo:
-il mondo sarà visto come un cubo, dove all'interno potremo mettere i nostri meteoriti
-il mondo sarà diviso in celle: ad ogni cella sarà assegnata una sezione del mondo, e dentro ogni sezione ci sarà la lista degli elementi che sono contenuti dentro tale sezione

Perchè le sezioni? Perchè se ho un mondo molto grande potrei dover renderizzare tanti troppi elementi a schermo, e questo rallenterebbe di molto il numero di frame per secondo. Dividendo in sezioni il mondo potremmo decidere di renderizzare solo quelle adiacenti a noi.
Inoltre se poi in futuro dovremmo calcolare la collisione di una fantomatica astronave con un meteorite, invece di controllare le collisioni con tutti i meteoriti della scena (cosa veramente masochistica, che poterebbe via tantissimo tempo) potremmo semplicemente farlo con quelli adiacetni alla sezione in cui ci troviamo.
Pensante a quanto tempo occorre scorrere un cubo in cui ogni lato è diviso in 20 sezioni!
Cioè ci sono 20*20*20 sezioni da controllare! Ognuna con più elementi!

Avendo suddiviso un mondo cubico in sezioni ho deciso di usare un vettore a 3 dimensioni per gestire il gameWorld.
MeteorManager.cs Show/Hide


   public struct Trasformation
   {
       public Vector3 position;
       public float angleX, angleY, angleZ;
       public float scale;
       public Matrix world;

       public void Update()
       {
           world = Matrix.CreateScale(scale) * Matrix.CreateFromYawPitchRoll(angleY, angleX, angleZ) *
               Matrix.CreateTranslation(position);
       }
   }

   public struct Sezione
   {
       public Vector2 xRange, yRange, zRange;
       public List<Trasformation> myList;
   }
   /// <summary>
   /// This is a game component that implements IUpdateable.
   /// </summary>
   public class MeteorManager : Microsoft.Xna.Framework.GameComponent
   {
       CameraI myCamera;
       InputI inputDevice;
       Model myModel;
       Texture2D text;

       Sezione[, ,] gameWorld;

       //servono per dire in quale riga, colonna e profondità si trova la telecamera
       int cameraR, cameraC, cameraP;
      
       Effect currentEffect = null;
       public Effect CurrentEffect
       {
           get { return currentEffect; }
           set { currentEffect = value; }
       }

       //variabili per la dimensione del mondo
       float xRange, yRange, zRange;

       //numero di celle per ogni dimensione
       int cells = 20;

       public MeteorManager(Game game, Effect effect, int num, float xRange, float yRange, float zRange,
           string myModel, string texture)
           : base(game)
       {
           this.currentEffect = effect; //assegno l'effetto usato per il rendering
           this.myModel = Game.Content.Load<Model>(myModel); //carico il modello
           foreach (ModelMesh mesh in this.myModel.Meshes)
               foreach (ModelMeshPart mp in mesh.MeshParts)
                   mp.Effect = effect; //assegno l'effetto ad ogni parte del modello
           this.text = Game.Content.Load<Texture2D>(texture);//carico la texture che voglio usare
           //assegno le variabili per la dimensione del mondo
           this.xRange = xRange;
           this.yRange = yRange;
           this.zRange = zRange;
           myCamera = (CameraI)game.Services.GetService(typeof(CameraI)); //recupero il servizio per la telecamera
           inputDevice = (InputI)game.Services.GetService(typeof(InputI));//e quello per l'input
           gameWorld = new Sezione[cells, cells, cells];//creo la matrice del mondo
           makeWorld(num); //vado a creare i mondo
       }

       private void makeWorld(int num)
       {
           //calcolo quando spazio deve coprire ogni cella
           float ix = xRange + xRange;
           ix /= cells;
           float iy = yRange + yRange;
           iy /= cells;
           float iz = zRange + zRange;
           iz /= cells;
           Random rand = new Random();
           for (int i = 0; i < cells; i++)
           {
               for (int j = 0; j < cells; j++)
               {
                   for (int k = 0; k < cells; k++)
                   {
                       //per ogni cella vado a inserire quale zona del mondo copre
                       gameWorld[i, j, k].xRange = new Vector2(i * ix - xRange, (i + 1) * ix - xRange);
                       gameWorld[i, j, k].yRange = new Vector2(j * iy - yRange, (j + 1) * iy - yRange);
                       gameWorld[i, j, k].zRange = new Vector2(k * iz - zRange, (k + 1) * iz - zRange);
                       //vado a creare la lista per la posizione dei meteoriti contenuti nella lista
                       gameWorld[i, j, k].myList = new List<Trasformation>();
                       for (int a = 0; a < num; a++)
                       {
                           Trasformation t = new Trasformation();
                           //creo la posizione all'interno della zona associata
                           t.position.X = rand.Next((int)gameWorld[i, j, k].xRange.X, (int)gameWorld[i, j, k].xRange.Y);
                           t.position.Y = rand.Next((int)gameWorld[i, j, k].yRange.X, (int)gameWorld[i, j, k].yRange.Y);
                           t.position.Z = rand.Next((int)gameWorld[i, j, k].zRange.X, (int)gameWorld[i, j, k].zRange.Y);
                           //angolo casuale
                           t.angleX = rand.Next(0, 360);
                           t.angleY = rand.Next(0, 360);
                           t.angleZ = rand.Next(0, 360);
                           //scala = 1
                           t.scale = 1;
                           //creo la world matrix per quel particolare meteorite
                           t.world = Matrix.CreateScale(t.scale) *
                               Matrix.CreateFromYawPitchRoll(t.angleY, t.angleX, t.angleZ) *
                               Matrix.CreateTranslation(t.position);
                           gameWorld[i, j, k].myList.Add(t);
                       }
                   }
               }
           }
       }

       public override void Initialize()
       {
           base.Initialize();
       }

       public override void Update(GameTime gameTime)
       {
           checkCameraPosition();
           base.Update(gameTime);
       }

       public void Draw(GameTime gameTime)
       {
           currentEffect.Parameters["View"].SetValue(myCamera.View);
           currentEffect.Parameters["Projection"].SetValue(myCamera.Projection);
           currentEffect.Parameters["ColorMap"].SetValue(text);
           currentEffect.Parameters["Color"].SetValue(Color.Green.ToVector4());
           foreach (ModelMesh mesh in myModel.Meshes)
           {
               BoundingSphere s = new BoundingSphere(mesh.BoundingSphere.Center, mesh.BoundingSphere.Radius);
               float radius = s.Radius;
               int val = 8;
               for (int i = (cameraR - val); i <= this.cameraR + val; i++)
               {
                   for (int j = (this.cameraC - val); j <= this.cameraC + val; j++)
                   {
                       for (int k = (this.cameraP - val); k <= this.cameraP + val; k++)
                       {
                           int r = i % cells;
                           int c = j % cells;
                           int p = k % cells;
                           if(r < 0)
                               r = cells + r;
                           if(c < 0)
                               c = cells + c;
                           if(p < 0)
                               p = cells + p;
                           foreach (Trasformation tras in gameWorld[r % cells, c % cells, p % cells].myList)
                           {
                               s.Center = tras.position;
                               s.Radius = radius * tras.scale;
                              
                               ContainmentType ris = myCamera.CameraBoundingFrustum.Contains(s);
                               if (ris == ContainmentType.Contains || ris == ContainmentType.Intersects)
                               {
                                   currentEffect.Parameters["World"].SetValue(tras.world);
                                   mesh.Draw();
                               }
                           }
                       }
                   }
               }
           }
       }

       private void checkCameraPosition()
       {
           float var = (xRange + xRange) / cells;
           cameraR = (int)(myCamera.Position.X / var) + cells / 2;

           var = (yRange + yRange) / cells;
           cameraC = (int)(myCamera.Position.Y / var) + cells / 2; ;

           var = (zRange + zRange) / cells;
           cameraP = (int)(myCamera.Position.Z / var) + cells / 2; ;
       }
   }

Diamo una spiegazione di quello che ho fatto nei vari punti!


public MeteorManager(Game game, Effect effect, int num, float xRange, float yRange, float zRange,
       string myModel, string texture)
       : base(game)
   {
       this.currentEffect = effect; //assegno l'effetto usato per il rendering
       this.myModel = Game.Content.Load<Model>(myModel); //carico il modello
       foreach (ModelMesh mesh in this.myModel.Meshes)
           foreach (ModelMeshPart mp in mesh.MeshParts)
               mp.Effect = effect; //assegno l'effetto ad ogni parte del modello
       this.text = Game.Content.Load<Texture2D>(texture);//carico la texture che voglio usare
       //assegno le variabili per la dimensione del mondo
       this.xRange = xRange;
       this.yRange = yRange;
       this.zRange = zRange;
       myCamera = (CameraI)game.Services.GetService(typeof(CameraI)); //recupero il servizio per la telecamera
       inputDevice = (InputI)game.Services.GetService(typeof(InputI));//e quello per l'input
       gameWorld = new Sezione[cells, cells, cells];//creo la matrice del mondo
       makeWorld(num); //vado a creare i mondo
   }

Quello che fa il costruttore è questo:
assegna al currentEffect l'effetto passato (gli effect sono usati per caricare e gestire codice HLSL, che serve per renderizzare gli elementi della scena, ottenere effetti particolari etc; in questo esempio ho usato un mio piccolo effect che non fa altro che prendere la texture ed applicarla all'oggetto da renderizzare, senza calcolare nessuna luce, questo perchè è più veloce e semplice del basic Effect standard, e qui voglio andare ad ottenere più FPS possibili. Il file è allegato nella soluzione, ma qui non darò spiegazione di come funziona).
Poi carica il modello e la texture passate. Assegna il valore alle variabili che mi dicono quanto è grande il mondo.
Si recupera poi i riferimenti ai servizi della telecamera e del gestore dell'input.
GameWorld è la matrice cubica che andrà a contenere il mondo: ogni cella rappresenta una sezione, e ogni sezione avrò la sua lista di elementi.

Il metodo makeWorld, per quanto possa disorientare, non fa altro che creare e posizionare in modo radom num elementi per ogni sezione. A voi il compito di guardarlo o di chiedere qualcosa che non vi è chiaro qui.

Concentriamoci un attimo sul metodo checkCameraPosition invece, che è più curioso secondo me...


private void checkCameraPosition()
   {
       float var = (xRange + xRange) / cells;
       cameraR = (int)(myCamera.Position.X / var) + cells / 2;

       var = (yRange + yRange) / cells;
       cameraC = (int)(myCamera.Position.Y / var) + cells / 2; ;

       var = (zRange + zRange) / cells;
       cameraP = (int)(myCamera.Position.Z / var) + cells / 2; ;
   }

Questo metodo prende la posizione della telecamera e memorizza in 3 variabili l'indice di riga, colonna e profondità in cui si trova la telecamera.
Come si fa ad otterere tale risultato?
Prendo la variazione relativa ad ogni cella (cioè quanto spazio sulla dimensione X, per esempio, copre una cella). Poi prendo la posizione X della telecamera, la divido per questa variazione, e a tale risultato ci sommo la metà delle celle. La somma è necessaria perchè voglio che la posizione 0,0,0 sia il centro del mio mondo cubico!
Se non facessi così sarei invece posizionato ad un vertice del mondo.

Il metodo draw adesso, che non sto a riportare perchè è lungotto :O
Allora: nelle prime righe si assegna all'effetto usato per il rendering i valori opportuni, quindi la viewMatrix della telecamera, la projectionMatrix della telecamera, la texture dell'oggetto, e un colore.
Poi cominciamo a scorrere le mesh che compongono il nostro oggetto da renderizzare, in questo caso il nostro meteorite, che dovrà essere replicato tante volte.
Si crea una nuova BoundingSphere con centro e raggio presi dalla BoundingSphere della mesh in esame.
Le BoundingSphere sono usate per calcolare le collisioni tra volumi sferici, ma qui le userò per una cosa diversa ma molto utile ^__^

Poi cominciamo a scorrere le celli adiacenti alla posizione in cui si trova la telecamera: più val è grande maggiore è il numero di celle che considero adiacenti.
Poi riassetto gli indici, in modo che non vadano fuori dai limiti consentiti.
Scorro poi la lista di elementi della sezione data dagli indici r,c,p.
Modifico il centro ed il raggio della BoundingSphere, e calcolo se la sfera o contenuta o interseca il BoundingFrustum della telecamera e solo se lo è renderizzo il meteorite.

Perchè faccio ciò?
Perchè anche se renderizziamo solo le celle vicine a noi, eseguo di solito il draw anche per oggetti che mi sono alle spalle e che io non vedo. Facendo questo sprecherei tempo in rendering inutili, che vengono calcolati, ma il cui risultato non è visualizzato a schermo.
Il frustum della telecamera lo possiamo vedere come un cono che parte dal nostro punto di osservazione, o meglio un tronco di cono, che comincia alla distanza nearPlane e termina a farPlane.
Dato che prima di giungere a questo risultato ho fatto diverse prove, se non usassi il boundingFrustum otterrei con val = 8 qualcosa come soli 5 FPS. Con invece riesco ad arrivare a 70 FPS più o meno stabili! Un buon risultato!
Insomma quello che facciamo è controllare se il volume dato dalla boundingSphere adeguatamente settata è contenuto completamente o in parte nel cono visivo della telecamera, e solo se lo è renderizzo l'oggetto. E' molto più conveniente fare questo controllo che fare un rendering inutile!
E poi perchè usare le BoundingSphere? Perchè è un metodo comodo, semplice ed economico per calcolare il volume di un oggetto, perchè calcolarne il volume esatto controllando i poligoni/vertici è troppo oneroso secondo me (e poi non lo so fare XD).

E come lo calcolo il frustum?
Per questo bisogna andare a modifcare la telecamera!
Ecco il file della telecamera con tutte le modifiche apportate
Camera.cs Show/Hide


   public enum CameraMode
   {
       Fixed,
       Free,
       Rotate,
       Follow       
   }

   public interface CameraI
   {
       Matrix View
       { get; }

       Matrix Projection
       { get; }

       Vector3 Position
       { get; set; }

       Vector3 Up
       { get; set; }

       Vector3 Target
       { get; set; }

       float NearPlane
       { get; set; }

       float FarPlane
       { get; set; }

       CameraMode Mode
       { get; set; }

       BoundingFrustum CameraBoundingFrustum
       { get; }
   }

   public class Camera : Microsoft.Xna.Framework.GameComponent, CameraI
   {
       //riferimento al controllo dell'input
       protected InputI inputDevice;
       //varibili per la telecamera
       protected Matrix projection;
       protected Matrix view;
       protected Vector3 position = Vector3.Zero;
       protected Vector3 target = Vector3.Zero;
       protected Vector3 up = Vector3.Up;
       protected float aspectRatio;
       protected float nearPlane;
       protected float farPlane;
       protected BoundingFrustum cameraFrustum;
       //varibili per lo spostamento e per la rotazione
       protected float yaw, pitch;
       protected Vector3 movimento;
       protected float rotationRate = 100.0f;
       protected float movementRate = 15000.0f;

       protected CameraMode typeOfCamera = CameraMode.Fixed;

       public Camera(Game game)
           : base(game)
       {
           inputDevice = (InputI)game.Services.GetService(typeof(InputI));
           game.Services.AddService(typeof(CameraI), this);
           typeOfCamera = CameraMode.Fixed;
           nearPlane = 1.0f;
           farPlane = 100000f;
       }

       public override void Initialize()
       {
           base.Initialize();

           aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
               (float)Game.GraphicsDevice.Viewport.Height;
           Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, nearPlane, farPlane, out projection);
           Matrix.CreateLookAt(ref position, ref target, ref up, out view);
           cameraFrustum = new BoundingFrustum(view * projection);
       }

       private void updateFreeCamera(GameTime gameTime)
       {
           movimento = Vector3.Zero;
           float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
           if(inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
               pitch -= rotationRate * delta;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
               pitch += rotationRate * delta;
           if (pitch > 89)
               pitch = 89;
           if (pitch < -89)
               pitch = -89;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
               yaw -= rotationRate * delta;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
               yaw += rotationRate * delta;
           if (yaw > 360)
               yaw -= 360;
           if (yaw < 0)
               yaw += 360;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.W))
               movimento.Z -= movementRate * delta;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.S))
               movimento.Z += movementRate * delta;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.A))
               movimento.X -= movementRate * delta;
           if (inputDevice.actualKeyboardState.IsKeyDown(Keys.D))
               movimento.X += movementRate * delta;

           Matrix rotation = Matrix.CreateFromYawPitchRoll(MathHelper.ToRadians(yaw),
               MathHelper.ToRadians(pitch), 0.0f);
           Vector3.TransformNormal(ref movimento, ref rotation, out movimento);
           position += movimento;
           Vector3 transformedReference;
           Vector3 dir = new Vector3(0, 0, -1);
           Vector3.TransformNormal(ref dir, ref rotation, out transformedReference);
           Vector3.Add(ref position, ref transformedReference, out target);
       }

       public override void Update(GameTime gameTime)
       {
           if (typeOfCamera == CameraMode.Free)
               updateFreeCamera(gameTime);

           aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
                   (float)Game.GraphicsDevice.Viewport.Height;
           Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, nearPlane, farPlane, out projection);
           Matrix.CreateLookAt(ref position, ref target, ref up, out view);

           cameraFrustum.Matrix = view * projection;
           base.Update(gameTime);
       }

       #region CameraI Membri di

       public Matrix View
       {
           get { return view; }
       }

       public Matrix Projection
       {
           get { return projection; }
       }

       public Vector3 Position
       {
           get { return position; }
           set { position = value; }
       }

       public Vector3 Up
       {
           get { return up; }
           set { up = value; }
       }

       public Vector3 Target
       {
           get { return target; }
           set { target = value; }
       }

       public float NearPlane
       {
           get { return nearPlane; }
           set { nearPlane = value; }
       }

       public float FarPlane
       {
           get { return farPlane; }
           set { farPlane = value; }
       }

       public CameraMode Mode
       {
           get { return typeOfCamera; }
           set { typeOfCamera = value; }
       }

       public BoundingFrustum CameraBoundingFrustum
       {
           get { return cameraFrustum; }
       }

       #endregion
   }

Le parti importante da considerare sono:
l'enumeratore CameraMode: questo contiene i vari tipi di telecamera che mi sono venuti in mente. Per ora noi useremo solo Free, ma nulla vieta di implementare anche gli altri o di aggiungerne di nuovi!
Come si può vedere ho anche aggiunto alcuni campi all'interfaccia CameraI.
Aggiunta importate è la CameraBoundingFrustum, che verrà calcolato nel metodo Update.

Ora passiamo al metodo Update: per prima cosa andiamo a controllare il tipo di telecamera, e se è di tipo Free adiamo a chiamare il metodo per aggiornarla.
Poi si calcola la view e la projection matrix ed infine il boundigFrustum, dato dal prodotto delle view per la projection.

Vediamo il metodo updateFreeCamera:


   private void updateFreeCamera(GameTime gameTime)
   {
       movimento = Vector3.Zero;
       float delta = (float)gameTime.ElapsedGameTime.TotalSeconds;
       if(inputDevice.actualKeyboardState.IsKeyDown(Keys.Up))
           pitch -= rotationRate * delta;
       if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Down))
           pitch += rotationRate * delta;
       if (pitch > 89)
           pitch = 89;
       if (pitch < -89)
           pitch = -89;
       if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Right))
           yaw -= rotationRate * delta;
       if (inputDevice.actualKeyboardState.IsKeyDown(Keys.Left))
           yaw += rotationRate * delta;
       if (yaw > 360)
           yaw -= 360;
       if (yaw < 0)
           yaw += 360;
       if (inputDevice.actualKeyboardState.IsKeyDown(Keys.W))
           movimento.Z -= movementRate * delta;
       if (inputDevice.actualKeyboardState.IsKeyDown(Keys.S))
           movimento.Z += movementRate * delta;

       Matrix rotation = Matrix.CreateFromYawPitchRoll(MathHelper.ToRadians(yaw),
           MathHelper.ToRadians(pitch), 0.0f);
       Vector3.Transform(ref movimento, ref rotation, out movimento);
       position += movimento;
       Vector3 transformedReference;
       Vector3 dir = new Vector3(0, 0, -1);
       Vector3.Transform(ref dir, ref rotation, out transformedReference);
       Vector3.Add(ref position, ref transformedReference, out target);
   }

MovementRate e RotationRate sono due variabili definite nella classe e ci dicono quanto velocemente si muove e ruota la nostra telecamera.
A seconda dei tasti che premiamo andiamo a modifcare i valori di Pitch e Yaw (che stanno rispettivamente per l'angolo sull'asse X ed Y), oppure a spostare la posizone della telecamera.
Usando yaw e pitch creo una matrice di rotazione, che uso per trasformare (cioè per spostare lungo la direzione data dalla matrice) la posizione della telecamera.
La stessa cosa la faccio per la posizione del punto che sto osservando, cioè per il target.
Come possiamo vedere in questo metodo non c'è il calcolo per la creazione della view e della projection: qui si aggiorna solo il valore della posizione e del target, la creazione viene fatta nel metodo update.

E questo è tutto.
Ora si deve solo andare in Game1.cs e mettere questo nel metodo Initialize:


       defaultEffect = Content.Load<Effect>(@"Effects\Default");

       mman = new MeteorManager(this, defaultEffect, 5, maxX,
           maxY, maxZ, @"Models\asteroid1", @"Textures\asteroid1");
       Components.Add(mman);

Le due variabili vanno naturalmente create prima ^^
Questo ci dice di caricare il file Default.fx, e di creare il MeteorManager che avrà 5 elementi per ogni sezione.

Dato che il MeteorManager è un GameComponent e non un DrawableGameComponent bisogna dirgli noi quando renderizzarlo!
Quindi nel metodo Draw di Game1.cs va messo questo:
mman.Draw(gameTime);

Ma veramente serve tutta questa palla del CameraBoundingFrustum, delle collisioni e tutto il resto?
Fate una prova:
Andate nel file del MeteorManager, nel Draw(..) mettere val = 8 e commentate la riga dove fate il controllo sul risultato del CameraBoundingFrustum.Contains(..).
Io riesco ad ottenere soltanto 5-6 FPS.
Facendo il controllo passo a circa 70.

Voi che dite? Serve?
Per me si ^___^

Poi almeno così si è visto come creare un manager per un insieme di oggetti, e come cominciare a buttare giù una semplice struttura per un gioco... qui il compito è..... contatare tutti gli asteroidi XD Sai che spasso XD
Scherzi a parte, potrebbe comunque essere un'idea di base per la struttura di un semplice gioco!

Ci dovrebbero essere altri metodi per semplificare il rendering di istanze multiple dello stesso elemento, ma ancora non sono in grado di applicarli.
Spero vi sia stato utile tutto questo.

Se ci sono cose che non tornanto o sbagliate o che si possono fare meglio (il che è molto probabile) ditelo please :)

Alla prossima!

Intanto ecco i file allegati!
XNA-tut5.rar

Argomenti trattati:
Free camera
Camera Bounding Frustum

Fast Modelling 9 - Mecha

2009-08-24T14:10:00.003+02:00

Quando sono preoccupato per qualcosa e non trovo modo di distrarmi o pensare ad altro (non posso studiare perchè le cose non mi resterebbero in testa) mi metto a lavorare a qualcosa.

Questa è l'ultima fatica (ancora incompleta) data dalla mia disperata mente!

Può darsi che sarà il nuovo lavoro per un bel WIP.
Si vedrà come va avanti.
Cosa ne pensate? Vi piace? Oppure come "stile" non va bene?

Sarà comunque servito a distrarmi?
No, affatto...
Il problema di riuscire a fare più cose contemporaneamente è che anche i brutti pensieri permangono. Solo il sonno forse mi darà pace, e ora mi sta venendo una grande voglia di dormire...

Alla prossima...

Seifer Gunblade

2009-08-22T09:16:00.005+02:00

In questi giorni proprio non so cosa fare per ternemi occupato.
Ho tanti troppi pensieri per la testa, ma al contempo tanta troppe cose che vorrei fare...
Non mi succedeva da tanto tempo, e devo dire che è frustrante non avere la possibilità di realizzare tutto quello che si vorrebbe nell'arco di un solo giorno.

Comunque proseguendo sulla retta via cominciamo a descrivere cosa ho fatto.

Ho notato che parecchi degli accesi al blog sono stati fatti ricercando "Gunblade" o come costruirne uno (magari fossi in grado di farne uno vero XD).
Quindi ieri sera (mentre guardavo qualcosa alla tv... mi pare aspettassi Wasabi :P) mi sono detto "Cosa potrei fare come lavoro sempre in tema Gunblade?".
Eh purtroppo di Gunblade ce ne sta solo uno!
NO INVECE! C'è anche quello di quel maledetto ed antipatico di Seifer -.-

E allora non ci ho pensato troppo su, ho trovato una cavolo di immagine (a bassa risoluzione -.-) e mi sono messo a modellarlo!

Come forma è certamente più semplice rispetto al Revolver di Squall, con meno dettagli direi.
Poi avendo un'immagine a bassa risoluzione non ho potuto mettere tutti i dettagli che avrei voluto ?_?
Il risultato però non mi dispiace (per averci lavoraro al massimo un'oretta).

Come si può vedere è molto più semplice.
E mi chiedo come facesse Seifer a tirare quelle pizze tremente impugnando questo affare a mo di pistola e con una mano sola :O
Almeno quello di Squall lo si poteva usare a 2 mani e aveva una forma più a spada che a pistola...
I misteri della vita! :O

Poi devo dire che il modello "pistola automatica" mi piace poco, poi come ho detto, non ho potuto particolareggiare molto: anche così sono andato abbastanza a fantasia.
E anche usando una foto di una pistola automatica non posso mettere troppa roba che non "esiste" nel progetto gunblade, anche perchè dopo non tornano forme e posizioni.

Poi mi sono detto "E a metterli assieme entrambi come rende il tutto?"
Ecco a voi :)

Diaciamocelo....
Il gunblade di Seifer a confronto con quello di Squall sembra un coltellino svizzero XD
Dai quello di Squall è troppo più bello e massiccio!
Credo che l'unica arma che ispira più potenza sia la Buster Sword di Cloud :P

Bè come al solito spero vi piaccia, e se avete delle critiche da fare, anche sulla forma e sui dettagli dei modelli ditelo che provvedo a cambiare e a modifcare!

Inoltre una piccola richiesta: se qualcuno trova delle foto ad alta definizione del gunblade di Seifer me lo può dire? In questo modo potrò aggiungere altri dettagli :)

Eccovi i link per le immagini ad alta risoluzione :)
Seifer's Gunblade
Both Gunblade

The Xna-Way: Tutorial 4: Input

2009-08-14T08:00:00.001+02:00

Ok eccoci di nuovo qua.
Dopo aver visto la telecamera della scena, come si carica e renderizza un semplice modello voglio vedere ora come organizzare la gestione dell'input!

Come ho deciso di organizzare questa cosa?
Bè XNA ci da tutte le funzioni per gestire l'input da tastiera, da mouse e da gamePad. Come sempre lavoro solo su Windows, quindi io gestirò solo quello da mouse e da tastiera, anche se per ora mi dedicherò solo a quello da tastiera.

Lo stato della tastiera va aggiornato e controllato ad ogni ciclo di esecuzione, e il posto migliore per farlo è il metodo update.
Quindi posso pensare di organizzare un gameComponent per la gestione e aggiornamento dell'input da tastiera. Ma quanti e quali componenti devono/possono usare l'input?
Be così ad occhio io direi la nostra telecamera, e per ora un eventuale personaggio da muovere. Se poi ci fossero altri componenti potremmo avere dei problemi di accesso ai dati per l'input.
Sarebbe auspicabile che ogni componente che vuole accedere all'input acceda agli stessi dati, cioè alla stessa copia in memoria dei dati relativi all'input.

Come per la telecamera anche il gestore dell'input sarà visto come un servizio, al quale poi potremo accedere da ogni punto del nostro gioco.
Per fare questo quindi useremo un'interfaccia, che esporrà i metodi e le proprietà che ci servono, e una classe (un gameComponent) che implementi l'interfaccia.
L'interfaccia e la classe saranno rispettivamente InputI e MyInput.

Ecco il codice del file che andremo ad aggiungere alla nostra libreria di classi:
MyInput.cs
Show/Hide


   public interface InputI
   {
       KeyboardState KeyboardState { get; }
   }

   public class MyInput : Microsoft.Xna.Framework.GameComponent, InputI
   {
       KeyboardState kState;

       public MyInput(Game game)
           : base(game)
       {
           game.Services.AddService(typeof(InputI), this);
       }

       public override void Initialize()
       {
           base.Initialize();
       }

       public override void Update(GameTime gameTime)
       {
           kState = Keyboard.GetState();

           base.Update(gameTime);
       }

       #region InputI Membri di

       public KeyboardState KeyBoardState
       {
           get { return kState; }
       }

       #endregion
   }

Come sempre se in futuro ci servono nuove funzionalità esse verranno implementate, ma per ora non ci servono e basta quello che abbiamo.

Cosa fa il codice?
Bè la classe definisce un oggetto di tipo KeyboardState, il quale andrà a contenere lo stato della tastiera, è cioè quali sono i tasti premuni e non premuti.
Nel costrutture, come pensato, vado ad aggiungere il gameComponent alla lista dei Servizi.

Il metodo update fa una cosa semplicissima: ad ogni esecuzione aggiorna il valore attuale contenuto nella variabile kState, in modo che quando un altro componente vuole ottenere informazioni sulla tastiera otterrà sempre lo stato aggioranto.

Come posso recuperare il riferimento al servizio ed utilizzarlo?
Andiamo nella nostra classe Model3D, e andiamo ad aggiungere un campo di classe così:
InputI inputDevice;

che sarà usato per contenere il riferimento al nostro gestore dell'input.
Ne costruttore di Model3D andiamo ad aggiungere questa riga:
inputDevice = (InputI)game.Services.GetService(typeof(InputI));

è simile a quella usata per recuperare il riferimento al servizio che gestisce la telecamera, solo che questa recupera il servizio per l'output.
Nel metodo update della classe Model3D aggiugiamo queste righe sotto l'incremento dell'angolo sull'asse Y:

if(inputDevice.KeyBoardState.IsKeyDown(Keys.Up))
    angleX += 5f * (float)gameTime.ElapsedRealTime.TotalSeconds;

in modo che quando premiamo il tasto "up" l'angolo sull'asse X venga incrementato.
Bene quasi finito!

Andiamo nel file Game1.cs, aggiungiamo anche qui il campo
inputDevice = (InputI)game.Services.GetService(typeof(InputI));

e il costruttore trasfromiamolo così:

public Game1()
       {
           graphics = new GraphicsDeviceManager(this);
           Content.RootDirectory = "Content";
           counter = new FPSCounter(this);
           Components.Add(counter);

           myInput = new MyInput(this);
           Components.Add(myInput);

           myCamera = new Camera(this);
           Components.Add(myCamera);
       }

Come possiamo vedere ho creato ed aggiunto un oggetto di tipo MyInput alla collezione dei componenti.
Ma come mai l'ho fatto prima della telecamera?
Perchè se in un futuro amplierò le funzionalità della mia telecamera e vorrò usare l'input, se aggiungo prima la camera e poi l'input, quando nel costrutire la telecamera andrò a cercare di recuperare il riferimento al servizio che implementa l'interfaccia InputI mi ritornerà NULL, dato che tale servizio non sarà stato ancora aggiunto. Così facendo invece la telecamera lo troverebbe pronto.

Se ora avviamo il gioco, dovremmo vedere sempre il nostro asteroide che ruota, ma premendo il tasto SU ruoterà anche attorno all'asse X.
Fantastico! E anche molto semplice direi ^^

Bene facciamo un'ultima modifca e poi abbiamo finito per oggi!
Nel metodo update della classe Game1.cs andiamo ad eliminare la condizione del costrutto if (che riguarda il gamePad) con questa:

if (myInput.KeyBoardState.IsKeyDown(Keys.Escape))
   this.Exit();

in modo che premendo il tasto Escape allora il gioco verrà terminato!

Ok per oggi è tutto!
Spero di essere stato chiaro.
Anche questa volta niente sorgenti, dato che il file per il componente di Input è tutto listato qua sopra, e le modifiche da fare sono esigue.

Se qualcosa non vi torna ditelo senza problemi e correggo! :)

Alla prossima!

The Xna-Way: Tutorial 3: Modelli 3D

2009-08-11T16:05:00.027+02:00

Piccola introduzione all'uso dei modelli tridimensionali!
Ma proprio minimale eh ^^

Intanto ecco a voi il codice di questa piccola classe che ho creato per gestire un modello 3D.
Da dire che il concetto è sbagliato, perchè è errato pensare di fare e di creare un game component per ogni oggetto che vogliamo gestire. Avremmo in questo modo un aumento della complessità realizzativa e un calo di prestazioni dovuto al grande numero di componenenti in gioco. Di solito si userà un gestore per quegli oggetti che hanno un comportamento comune, e un oggetto apposito per quelli che hanno un comportamento particolare.
Ma per ora, per questi esempi semplici va più che bene.
Questo componenten va aggiunto al progetto myLibrary.

Model3D.cs
Show


public class Model3D : Microsoft.Xna.Framework.DrawableGameComponent
{
Model myModel;
Matrix world;

InputI inputDevice;

Vector3 position = Vector3.Zero;
float scale = 1.0f;
float angleX, angleY, angleZ;

CameraI myCamera;

public Model3D(Game game, string myModel)
    : base(game)
{
    position.Z = -8000;
    world = Matrix.Identity + Matrix.CreateTranslation(position);
    myCamera = (CameraI)game.Services.GetService(typeof(CameraI));
    this.myModel = Game.Content.Load<Model>(myModel);
}

public override void Update(GameTime gameTime)
{
    //prova rotazione
    angleY += 5f * (float)gameTime.ElapsedRealTime.TotalSeconds;
    //----------------------------------
    world = Matrix.CreateScale(scale) *
        Matrix.CreateFromYawPitchRoll(angleY, angleX, angleZ) *
        Matrix.CreateTranslation(position);
    base.Update(gameTime);
}

public override void Draw(GameTime gameTime)
{
    Matrix[] transforms = new Matrix[myModel.Bones.Count];
    myModel.CopyAbsoluteBoneTransformsTo(transforms);

    foreach (ModelMesh mesh in myModel.Meshes)
    {
        foreach (BasicEffect be in mesh.Effects)
        {
            be.EnableDefaultLighting();
            be.Projection = myCamera.Projection;
            be.View = myCamera.View;
            be.World = world * transforms[mesh.ParentBone.Index];
        }

        mesh.Draw();
    }

    base.Draw(gameTime);
}
}

Come si può vedere la classe Model3D.cs deriva da DrawableGameComponent, in questo modo ha il suo metodo Draw.

Model3D ha come campi privati un oggetto myModel di tipo Model che servirà per contenere il modello che andremo a caricare.
Poi ha un vettore per la sua posizione nel mondo 3D della scena, 3 variabili per il valore della rotazione lungo i 2 assi (X, Y, e Z) e una variabile per la scala dell'oggetto (cioè per dire quanto deve essere grande l'oggetto).

La matrice chiamata world è la matrice che costruiremo usando le varabili che caratterizzano la posizione del nostro oggetto nel mondo.

Ha anche un oggetto di tipo CameraI che andrà a contenere il riferimento al servizio della telecamera. Ma come lo recuperiamo? :O

Al costruttore gli passiamo (oltre al game) il percorso dove è situato il modello che vogliamo caricare. In questo modo possiamo caricarlo ed assegnarlo al nostro oggetto.
Per fare questo usiamo il metodo Load di Content. Questo Metodo ci permette di caricare molti dei contenuti multimediali che vogliamo usare nel nostro gioco, come i modelli appunto, musica, immagini, etc.
Non mi dilungo nello spiegare cosa faccia, ma in parole povere è come se riscrivesse l'oggetto che vogliamo caricare in un formato compatibile ed utilizzabile da XNA sia su pc che sulla 360.

Concentriamoci un attimo su questa riga:
myCamera = (CameraI)game.Services.GetService(typeof(CameraI));

Cosa fa? Abbiamo visto nel file Camera.cs come aggiungere un servizio, che poi non era altro che un gameComponent che implementava un'interfaccia.
Questo metodo ci permette di recuperare il riferimento ad un servizio che abbiamo aggiunto, e di far riferimento sempre alla solita copia di quel servizio da ogni punto del nostro gioco.
In questo caso andiamo a prendere il riferimento al serivizio che si occupa gestire la telecamera.
Naturalmente potremo accedere solo ai metodi e proprietà definite nell'interfaccia.
Ci serve di recuperare il riferimento alla telecamera perchè per la fase di rendering dell'oggetto abbiamo bisogno di un paio di informazioni da parte della camera.

Fatto questo cambiamo il valore z del vettore position, in modo che sia distante dal punto di osservazione della telecamera e sia ben visibile.

Nel metodo update aggiungiamo questo:

angleY += 5f;
world = Matrix.CreateScale(scale) *
        Matrix.CreateFromYawPitchRoll(angleY, angleX, angleZ) *
        Matrix.CreateTranslation(position);

Questo codice incrementa il valore dell'angolo di rotazione sull'asse Y di 5 gradi ad ogni esecuzione del metodo update, e dopo ricostruisce la matrice world.
La matrice world è costruita prima calcoando la matrice per la scala, poi per la rotazione ed infine per la traslazione.
Per calcolare la rotazione usiamo il CreateFromYawPitchRoll: questi termini (Yaw, Pitch, Roll) indicano rispettivamente il valore della rotazione attorno agli assi Y, X, e Z (cioè Yaw = Y, Pitch = X, e Roll = Z). Ecco perchè al metodo gli passo prima l'angolo per l'asse Y, poi per X ed infine per Z.

Di solito si segue questo ordine, anche perchè la moltiplicazione tra matrici non è commutativa ed eseguire questa moltiplicazione con un ordine diverso porta a risultati doversi.

Ora andiamo al metodo Draw!


            foreach (ModelMesh mesh in myModel.Meshes)
            {
                foreach (BasicEffect be in mesh.Effects)
                {
                    be.EnableDefaultLighting();
                    be.Projection = myCamera.Projection;
                    be.View = myCamera.View;
                    be.World = world;
                }

                mesh.Draw();
            }
            
            base.Draw(gameTime);

Questo è il classico ciclo di esecuzione per renderizzare un modello tridimensionale.
Fatto copia incolla dal manualone (vantiamocene eh XD).
Quello che fa è più o meno questo: per ogni mesh contenuta nel modello (dato che un modello può essere composto da più mesh) prende il basicEffect della mesh attuale, imposta i valori per la projection matrix, view matrix (per dire come è fatto il punto di osservazione) prelevandoli dal servizio che gestisce la telecamera (ecco a cosa ci serviva il riferimento ad essa!). Poi dobbiamo impostare il valore per la world matrix, che rappresenta la posizione, la rotazione e la scala del nostro oggetto nella scena. Infine renderizza la parte in esame.

Come si fa ad usare questo componente che abbiamo appena creato?
Nel progetto che stiamo usando, dopo aver aggiungo la telecamera come visto l'altra volta, andiamo nel file Game1.cs e nel metodo Inizialize aggiungiamo questo codice:

Model3D modell = new Model3D(this, @"Models\asteroid1");
Components.Add(modell);

Per fare questo dovrete aggiungere nella cartella Content del progetto due cartelle: una chiamata Models, dove andremo a mettere il modello del nostro asteroide, e un'altra chiamata Textures, dove andremo a mettere la texture del nostro modello (che verrà caricata in automatico assieme al modello).
Come possiamo notare, quando andiamo a caricare il modello, e a specificare il nome dell'oggetto da caricare, non mettiamo l'estensione. Questo perchè non ci serve, dato che l'oggetto è già stato passato nella content Pipeline di XNA. Se vogliamo quindi riferirci ad un oggetto per caricarlo, come in questo caso, gli dobbiamo dare solo il nome, senza estensione.
Questo codice crea ed aggiunge li componente per la gestione del modello.

Avviando il gioco se tutto va bene dovremmo vedere un meteorite che ruota su se stesso.
Ora abbiamo due possibilità: o il metorite ruota lentamente o va come una scheggia.
Se va lentamente è perchè non abbiamo creato ed aggiunto il gameComponente per il conteggio degli FPS, se va come una scheggià per perchè lo abbiamo creato.
Ricordo che il componente per il conteggio degli FPS toglie il limite al numero di volte che il metodo Update viene chiamato in un secondo.
Per usare l'FPSCounter e far ruotare il modello alla velocità giusta cambiamo il codice per l'aggiornamento dell'angolo in questo modo:

angleY += 5f * (float)gameTime.ElapsedRealTime.TotalSeconds;

Accedendo al gameTime, e prendendo il valore ElapsedRealTime non facciamo altro che recuperare il tempo passato dall'ultima invocazione del metodo Update. Così facendo l'incremento non sarà di 5 gradi ad ogni invocazione del metodo, ma di una frazione di 5 ad ogni invocazione del metodo.
In questo modo l'incremento sarà fatto alla giusta velocità, sia usando che non usando l'FPSCounter. Difatti se proviamo ad eseguire il codice prima con FPSCounter e poi senza notiamo che non c'è differenza nella velocità di rotazione dell'oggetto.

Spero sia chiaro.

Come ho detto questo è solo un esempio, e di solito non si fa una cosa del genere. Ma per addentrarci un po' nel caricamento e nella renderizzazione degli oggetti 3D credo possa andare.

Eccovi intanto i sorgeti di quanto fatto:
XNA-tut3.rar
Alla prossima :)

The Xna-Way: Tutorial 2: Camera

2009-08-11T15:17:00.028+02:00

Finalmente trovo il tempo e la voglia di scrivere qualche altra riga.
Questa volta mi sono occupato della camera della scena. Una semplice telecamera fissa, perchè per poter aggiungere altre funzionalità dovrò prima implementare altri servizi e componenti, tra i quali quelli per gestire l'input da tastiera (e mouse) e un modo semplice per renderizzare qualcosa a scena.

Purtroppo per vedere gli effetti di quanto scrivo dovremo attentere il prossimo articolo. Questo non perchè non funziona, ma solo perchè non ci sarà niente da renderizzare nella scena (come ho detto dovrò poi implementare un qualcosa per far renderizzare un modello tridimensionale!)
Questo componenten va aggiunto al progetto myLibrary.
Ecco il codice del file:

Camera.cs
Hide/Show


public interface CameraI
{
  Matrix View
  { get; }

  Matrix Projection
  { get; }
}

public class Camera : Microsoft.Xna.Framework.GameComponent, CameraI
{
  //varibili per la telecamera
  Matrix projection;
  Matrix view;
  Vector3 position = new Vector3(0.0f, 0.0f, 20.0f);
  Vector3 target = Vector3.Zero;
  Vector3 up = Vector3.Up;

  public Camera(Game game)
      : base(game)
  {
      game.Services.AddService(typeof(CameraI), this);
  }

  public override void Initialize()
  {
      base.Initialize();

      float aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
          (float)Game.GraphicsDevice.Viewport.Height;
      Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, 1.0f, 10000.0f, out projection);
      Matrix.CreateLookAt(ref position, ref target, ref up, out view);
  }

  public override void Update(GameTime gameTime)
  {
      base.Update(gameTime);
  }

  #region CameraI Membri di

  public Matrix View
  {
      get { return view; }
  }

  public Matrix Projection
  {
      get { return projection; }
  }

  #endregion
}

Naturalmente nessuno ci vieta di aggiungere funzionalità al nostro codice in futuro :)

Analizziamo il codice pezzo a pezzo:
il vettore position è quello che contiene la posizione dal quale stiamo osservando la scena, mentre target è il vettore che contiene il punto che stiamo osservando.
Up è il vettore che indica in quale direzione è l'alto nella scena.
Con il codice scritto abbiamo che la telecamera (o punto di osservazione) è posizionato in posizione X = 0, Y = 0, Z = 20.
Stiamo osservando il punto X = Y = Z = 0, e l'alto è dato dal vettore con componente Y positiva (in teoria [0,1,0]).

float aspectRatio = (float)Game.GraphicsDevice.Viewport.Width /
     (float)Game.GraphicsDevice.Viewport.Height;
Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
     aspectRatio, 1.0f, 10000.0f, out projection);
Matrix.CreateLookAt(ref position, ref target, ref up, out view);

Con questo codice creiamo prima di tutto il rapporto tra le dimensioni del nostro schermo (di solito un televisore è in 4:3 o 16:9). Nel nostro caso il rapporto è tra la larghezza e l'altezza delle dimensioni dell'area di rendering.
Per accedere a questa informazione utiliziamo
Game.GraphicsDevice.Viewport.Width e Game.GraphicsDevice.Viewport.Height.

Queste informazioni vengono utilizzate poi per creare la projection matrix: questa matrice serve a definire come viene presentato a schermo quello che viene renderizzato nella scena. Gli ultimi due parametri numerici sono il nearPlane e il farPlane. Indicano i limiti di quanto è possibile vedere: cioè tutto quello che risulterà distante dalla telecameta e tra nearPlane e farPlane sarà visibile.
Come si può vedere gli passiamo anche l'aspectRatio calcolato prima.
L'ultimo parametro, quello con "out", definisce in quale variabile andrà a finire il risultato.

La view matrix identifca la telecamera, e ci serve a definire in quale punto siamo, cosa stiamo osservando, e dove si trova la direzione dell'alto. Come si vede per calcolarla si utilizza le tre variabili definite prima.

Per ora la telecamera è fissa, cioè non si muove, non cambia punto di osservazione... Nulla un punto fisso.
Questo è il più semplice tipo di telecamera che si piò creare. Si potrà poi utilizzare questa classe come base per ereditare altri tipi di telecamere.

Per poterla utilizzare, nel costruttore di Game1.cs si deve creare un oggetto di tipo camera ed aggiungerlo alla collezione dei components.

Torniamo un attimo al costruttore della telecamera, ed osserviamo questa riga:
game.Services.AddService(typeof(CameraI), this);
Che cosa fa?
Be con l'FPSCounter avevamo visto come creare un component ed aggiungerlo alla collezione dei Components in modo che poi venisse gestito in automatico.
Quello che faccio ora è creare un servizio: un servizio è un componente che implementa un'interfaccia. Tramite questa interfaccia possiamo poi riferire il servizio ed accedere al servizio stesso tramite i metodi e le proprietà definite dall'interfaccia.
C'è da dire però che ci deve essere nei Services un solo oggetto che implementa una certa interfaccia. Quindi non posso aggiungere due gestori per la camera che implementano la CameraI, dato che poi non sapremo come recupere l'uno o l'altro. Se voglio aggiungere due telecamere diverse i due oggetti devono implementare due interfacce diverse.
Per aggiungerlo alla collezione dei servizi dobbiamo prima di tutto accedere tramite l'oggetto game alla collezione dei servizi, e poi gli dobbiamo dire di che tipo considerare l'oggetto che stiamo aggiungendo (in questo caso come un tipo CameraI) e l'oggetto da aggiungere (in questo caso l'oggetto che stiamo costruendo e quindi this).
Vediamo infatti che la notra classe implementa l'interfaccia CameraI, la quale definisce delle proprietà che andranno a recuperare i valori della projection e della view matrix.
Quando in un altro punto del nostro gioco andremo a recuperare il riferimento al servizio che implementa la CameraI andremo a recuperare il riferimento del solito oggetto, e quindi andremo a recuperare sempre le stesse informazioni.

Per ora finisco qui.
La prossima volta vedrò di dire come si può creare un componente che si occupa di caricare e renderizzare nella scena un oggetto tridimensionale, e come recueperare il riferimento al servizio della camera appena creato ed aggiunto.

Questa volta niente sorgenti, dato che ho messo il file completo nel post :)
Spero di essere stato chiaro.
Se qualcosa è spiegato frettolosamente o in malo modo ditelo e provvederò a correggere! :D

Ciau! Alla prossima!

Fast Modelling 8 - armchair

2009-08-04T15:17:00.008+02:00

Altra giornata divisa tra un progetto per l'università (anche se portato avanti lentamente e con poca voglia), uno strano malumore generale, fatica fisica (le legne per l'inverno vanno messe a posto nella legnaia eh!)...
Si arriva alla sera e cosa si fa?
Da un lato il libro su XNA (che non ho abbandonato eh, solo che devo sperimentare alcune cose e scrivere qualche altro esempio per capire come funzionano delle cose poi vi farò sapere ^^), o la possibilità di modellare qualcosa di veloce e possibilmente indolore...

Secondo voi se state a leggere queste righe, cosa avrò mai fatto?

Quando stavo pensando a cosa poter fare, mi sono girato di scatto a destra sentondo un ronzio di una zanzare (maledetta!) e cosa ho visto?
La poltrona!
E allora ho cominciato a modellare la poltroncina che ho di fianco, cercando di mantenere una struttura semplice.
Il risultato dopo 15-20 minuti di lavoro è stato il seguente:
Devo dire che il mio stesso lavoro non mi è piaciuto più di tanto... Sinceramente speravo di giungere ad un risultato migliore.... Ok direte voi potevi interrompere o modificare il tutto, ma quanto mi prendono questi "attacchi" non posso: come chi butta giù una bozza non si ferma fino a lavoro finito io faccio lo stesso. Non mollo fino a quando non sento che sono arrivato alla fine.
Erò però deciso a fare di meglio.
Ho quindi cercanto sul mitico Google qualche immagine di poltrone (cavolo non pensavo ce ne potessero essere di tanti tipi, forme, stili, decorate e non, moderne o romantiche, etc....
Insomma dopo un quarto d'ora buono a spulciare poltrone, ho trovato quella con la forma che facaveva al caso mio.
Altri 20 minuti di lavoro ed ecco il risultato:
Ora si che ero abbastanza soddisfatto del mio operato.
Non ci avrei dormito bene la notte poi (tutte balle XD).
Quindi ora dovevo solo scegliere il colore, controllare il codice sul catalogo, compilare il modulo e l'ordinazione era pronta...
Ok sto delirando!

Dopo qualche prova di texturizzazione, e qualche rendering andato male, questo è stato il mio risultato:
Se volete il prezzo per il prodotto è di 70€ spese di spedizione escluse (XD).

Tutto sommato mi sono divertito.
Spero vi piaccia, anche se non è proprio il massimo lo so... come al solito potevo spenderci un po' più di tempo e forse veniva meglio...
Comunque basta piangere.

Se avete qualche commento, prego non esitate :)

Alla prossima!

The Xna-Way: Tutorial 1: FPS Counter

2009-07-31T19:30:00.003+02:00

Salve a tutti!
Ho deciso di cominciare il prima possibile a scrivere qualcosa riguardante il magnifico mondo dell'XNA.
Le mie conoscenze a riguardo sono per ora esigue, ed è per questo che ho deciso di scrivere qui quello che produrrò di "utile" di volta in volta, in modo da poter rendere diponibile ad altri quel poco che imparerò e per fare in modo che gli sventurati che capiteranno da queste parti e che ne sanno più di me, vedendo i miei strafaciolni, possano (se vogliono) correggermi!

Detto questo cominciamo! ^^

Dato che ho appena incominciato ad avventurarmi in questo mondo non andrò a buttarmi in spiegazioni troppo complicate o astruse...
Anche perchè il mio "sapere" aumenterà mano a mano che proseguirò con la lettura del manuale! Quindi per ora sono un po' a secco...

Cosa abbiamo appreso intanto?
Bè dopo aver scaricato dal sito della microsoft l'ultimo Microsoft Visual C# 2008 Express Edition e XNA 3.1, ho deciso di mettermi all'opera.
Nota: io non ho una X-Box 360 (eh lo so sono stronzo ?_?), quindi tutto il codice che andrò a scrivere sarà per Windows.
Naturalmente il codice potrà funzionare anche su una 360, solo che alle volte si dovranno fare delle modifiche. Quello che conta è che il concetto che sta dietro è lo stesso.

Dopo la creazione di un nuovo progetto di prova quello che appare è un file Game1.cs contenente il seguente codice:

 public class Game1 : Microsoft.Xna.Framework.Game
{
    GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;

    public Game1()
    {
        graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
    }

    protected override void Initialize()
    {
        base.Initialize();
    }

    protected override void LoadContent()
    {
        spriteBatch = new SpriteBatch(GraphicsDevice);
    }

    protected override void UnloadContent()
    {
    }

    protected override void Update(GameTime gameTime)
    {
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            this.Exit();

        base.Update(gameTime);
    }

    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);

        base.Draw(gameTime);
    }
}

A cosa sono questi metodi a grandi linee?
Il Game1() è il costrutture della nostra classe Game1, nella quale andremo a creare tutti gli oggetti che ci serviranno per la nostra applicazione.
Inizialize() è il metodo che viene chiamato dopo il costruttore, e qui andremo ad inizializzare tutti i valori che ci servono.
Il LoadContent() viene chiamato dopo l'Initialize() e sarà il metodo dove inseriremo il caricamento dei file che ci servono, come i file audio, i modelli 3D, le immagini, etc. Insomma di tutta quella roba che sfrutta il il ContentPipeline di XNA per il caricamento degli elementi del gioco.
Dal contempo l'UnloadContent viene chiamato alla chiusura dell'applicazione serve a liverare la memoria occupata dai file caricati.
Il "cuore" della nostra applicazione sono i metodi Update() e Draw().
Questi metodi vengono chiamati a ripetizione, cioè Upadate()-Draw()-Update()-Draw() e così via fino a quando non viene chiusa l'appliacazione.
In Update() verrà messo il codice che serve ad aggiornare lo stato del nostro gioco, come la posizione della telecamera, la posizione dei nemici,...
Nel metodo Draw() tutto il codice che serve a disegnare, a renderizzare, la scena del gioco a schermo.

Se facciamo partire il programma adesso l'unica cosa che vedremo è una scena vuota a tinta unita.

Cosa vogliamo fare adesso?
Bè io intanto volevo vedere gli FPS della scena, anche per rendermi conto quando va veloce il tutto ^^

Si potrebbe pensare di mettere tutto il codice che ci serve nel file Game1.cs.
Certo funzionerebbe, ma dopo che avevo cominciato a scrivere qualcosa mi sono renso conto di questo: adesso metto il conteggio dei frame nel Draw(), poi dovrò renderizzare altri elementi quando mi servono, poi potrei voler fare qualche altra cosa etc.
Tutto questo dopo un po' renderebbe le cose confusionarie, portanto il codice ad una cattiva lettura e bassa possibilità di fare manutenzione e correzione.
Poi diciamocelo, C# è un linguaggio ad oggetti e ci sarà pure il modo di fare fare un oggetto che mi faccia il conto degli FPS da solo e possibilmente in automatico!
Meglio quindi cercare una soluzione più comoda e al contempo performante, cercando al contempo di suddividere il codice in più unità logiche cooperanti.

Con XNA possiamo utilizzare i GameComponents. Con i GameComponent possiamo organizzare al loro interno parte delle operazioni che vogliamo far fare al nostro gioco, e queste operazioni saranno poi richiamate automaticamente dal Framework di XNA.
Infatti XNA ci da la possibilità di gestire una collezione di GameComponents, alla quale possiamo aggiungere gli elementi che vogliamo siano gestiti come GameComponent.
Quindi in questo caso possiamo creare un GameComponent per il calcolo degli FPS, un GameComponent per la gestione e il movimento della telecamera, etc.
Però non dobbiamo pensare che per ogni oggetto che vogliamo gestire si possa creare un GameComponent non va bene. Ma per ora questa cosa non ci tocca. Si affronterà in seguito.
Andiamo quindi a creare il codice del nostro FPS Counter.

Per avere un'ulteriore suddivisione tra il codice del gioco e dei vari elementi che andremo a creare ho deciso di mettere tutti gli elementi in una GameLibrary (nel mio caso una WindowsGameLibrary, chi volesse provare il codice su una 360 devrà creare una X-BOX 360 Library).

Ho quindi creato il mio progetto libreria, chiamato myLibrary (che fantasia -.-).
Aggiungiamo un nuovo elemento al progetto, aggiungendo un GameComponent e chiamiamolo FPSCounter.
Fatto questo invece di far derivare FPSCounter da GameComponent facciamolo derivare da DrawableGameComponent, in questo modo il nostro FPSCount avrà il suo metodo Draw che verrà chiamato in automatico da XNA! (invece il GameComponent classico non offre questo metodo). E voi come direte... e ce ne importa del metodo Draw()?
Bè per contare gli FPS ci serve il metodo Draw() dato che gli FPS indicano il numero di volte al secondo che una scena viene renderizzata.

Per calcolare il valore FPS ci servono le seguenti variabili:
una variabile per tenere a mente il numero di volte che abbiamo renderizzato la scena (frameCount)
una varibile per tenere a mente quando abbiamo renderizzato l'ultima volta la scena (timeLastDraw)
Quelle che ho usato io, e che ho definito nella classe FPSCounter sono:

private int frameCount = 0;
private float intervall;
private float elapsedTime;
private float timeLastDraw;
private float fpsValue;

Dove intervall è l'intervallo in cui voglio misurare il numero di frame (in questo caso un secondo).
elapsedTime contiene il tempo che è passato dall'ultima invocazione di Draw().
fpsValue non credo che abbia bisogno di spiegazioni ^^.

L'unico metodo che ci interessa è il Draw(), ed è questo che andremo a ridefinire.
Tutti gli altri, costruttore a parte, possono essere cancellati.
Per ora nel costruttore mettiamo solo
intervall = 1.0f;

mentre il metodo Draw() sarà così fatto:

elapsedTime = (float)gameTime.ElapsedRealTime.TotalSeconds;
frameCount++;
timeLastDraw += elapsedTime;
if (timeLastDraw > intervall)
{
  fpsValue = frameCount / intervall;
  frameCount = 0;
  timeLastDraw -= intervall;
  Game.Window.Title = fpsValue.ToString();
}
base.Draw(gameTime);

prima ci calcoliamo quanto tempo è passato dall'ultima invocazione di Draw(), poi incrementiamo il frameCount, ed aggiungiamo il valore di elapsedTime a timeLastDraw, e poi controlliamo il valore di timeLastDraw.
Se il suo valore è maggiore di intervall, quindi di un secondo, calcolo il valore di fpsValue, azzero il frameCount, sottraggo intervall a timeLastDraw.
Come ultima operazione mostro il valore di fpsValue nella barra del titolo della finestra in cui è avviata l'applicazione (questo fa solo su Windows).

Ok fatto questo dobbiamo ora avviare il counter assieme al programma.
Come collegarla con la nostra applicazione, e cioè con il Game1.cs?
Prima di tutto aggiungiamo il riferimento alla nostra libreria: nell'esplora soluzioni facciamo tassto destro su riferimenti->aggiungi riferimento->scheda progetti->selezioniamo il nostro progetto myLibrary.
Fatto questo in vetta al file Game1.cs, sotto tutti gli altri using, mettiamo questa riga:
using myLibrary
Nel file Game1.cs mettiamo una varibile di classe come questa:

FPSCounter counter;

e dentro il costruttore di Game1.cs aggiungiamo:

counter = new FPSCounter(this);
Components.Add(counter);

Queste righe creano un nuovo FPSCounter e lo aggiungono alla collezione di GameComponent del nostro gioco.
Ricordo che i GameComponent vengono eseguiti automaticamente da XNA.

Quello che vi dovrebbe apparire è un valore nella barra del titolo al posto del nome della vostra applicazione.
Dovrebbe apparirivi un valore pari a 60, o che oscilla tra 58 e 60.
Ora dico...
Ho rifatto nuovo il portatile, e avere un "gioco" senza nulla scena che mi da 60 FPS mi pare un po' pochino...

Perchè accade questo?
Perchè XNA è impostato per fare il ciclo di chiamata Update-Draw 60 volte al secondo.
Quindi se anche fosse possibile renderizzare ad una velocità più alta lui la limita.

Come possiamo ovviare a questo limite?
Per renderizzare al massimo della velocità dobbiamo mettere queste righe di codice nel costruttore di FPS:

GraphicsDeviceManager manager = (GraphicsDeviceManager)Game.Services.GetService(typeof(IGraphicsDeviceManager));

manager.SynchronizeWithVerticalRetrace = false;
Game.IsFixedTimeStep = false;

Con queste andiamo a prendere il servizio che fa da gestore per la grafica del gioco,
e con le altre righe gli diciamo che deve renderizzare il più velocemente possibile.
Più precisamente: mettendo a false il valore SynchronizeWithVerticalRetrace dico che non deve sincronizzarsi con la frequenza del monitor, mentre con IsFixedTimeStep a false dico che non deve chiamare il metodo Update alla frequenza di default di 60 volte al secondo.

Facendo rieseguire ora ottengo un valore che si aggira sui 1500 FPS...
Già meglio cavolo :)

Per ora basta gente ^^
Spero di essere stato chiaro.
Come sempre se qualcosa non torna, se volete esprimere un commento, proporre una modifica, etc, siete liberissimi di farlo!

Ecco intanto il codice prodotto fino ad ora!
XNA-tut1.rar

Alla possima!

Fast Modelling 7 - GamePad

2009-07-29T19:16:00.002+02:00

Cosa fare quando si è stanchi fisicamente, quando non avete voglia di fare un po' di fatica fisica, quando avete la testa che vi fa male, quando avete la mente assillata da pensieri che non pensavate di avere e che alle volte non vorreste avere?

Ma buttiamoci sulla modellazazione e vediamo di fare qualcosa...

Cosa si realizza oggi?
Avevo accando al pc un gamePad, quindi senza pensarci troppo su ho cominciato a modellare un cavolo di gamePad...

Devo dire che il design non mi piace per niente, poteva essere fatto meglio.
Avrei potuto avere anche un workFlow migliore...
Avrei potuto fare tante cose molto meglio, ma è andata così...
Tempo di realizzazione?
Direi circa 30 minuti, comprendendo controlli a forum e siti nel frattempo...

30 minuti in cui ho tenuto la testa occupata e in cui non ho pensato a nulla?
Magari... 30 minuti passati a modellare sto coso, sempre assillato da questo rumore di sottofondo che è la mia mente, ottenendo solo un qualcosa che mi convince poco e nulla...

Se avrò tempo e voglia vedrò di modificarlo e di fare un rendering (spero decente).

Alla prossima!
Sperando di essere più in forma...

The Xna-Way

2009-07-26T12:30:00.004+02:00

Piccola comunicazione.
Dato che adesso ho un po' più di tempo libero davanti a me, causa "vacanze estive" (se così si possono chiamare) ho il tempo di dedicarmi alla lettura e allo studio del manualone sull'XNA.

Quindi molto probabilmente comincerò a scrivere qualche programmino per XNA, e credo che posterò qua i risultati, il codice e se riesco qualche piccolo tutorial o aiuto.
Non per farmi passare per un esperto, solo che cominciando a studiarlo voglio condividere con chi è interessato i miei dubbi, "scoperte" e piccoli passi in avanti.
Così almeno chi ne sa più di me potrà darmi qualche capaccione e rimettermi sulla giusta strada :)

E per questo che in alto è stata aggiunta alla barra la voce Xna-Way, sotto il cui nome andranno tutti i post riguardati questo tema.

Nota: oltre alla voce Xna-Way è stata aggiunta quella per Lightwave, dato che ormai cominciano ad esserci diversi post a riguardo.

Alla prossima, e spero con un po' di nuovo materiale! :)

Fast Modelling 6 - Ampolla

2009-07-25T13:00:00.004+02:00

Anche oggi ero in vena di fare alcune prove.
Sto cercando di sbizzarirmi in nuove scene e di vedere come vengono elborate le varie parti.

Anche questa volta la scena è semplicissima:
un'ampolla, con dentro un pianeta o_O
Ok non è che sia proprio il massimo come realismo lo ammetto, ma mi è venuto in mento quando ho ripensato alla scena finale di Men In Black (mitico film :D).
Quindi ho pensato di fare un qualcosa di simile.

Dopo aver creato la scena, ho deciso di mettere più copie dello stesso oggetto, in modo che ottenere anche più riflessioni tra le varie copie.
Come potete vedere l'effetto ottenuto non è che sia proprio realistico, ma guardando le altre ampolle in secondo piano si nota che ci sono i riflessi.
Mi sono fatto un'idea anche di come risulta l'effetto di rifrazione nei materiali trasparenti. Il problema è quando questo effetto è comulativo tra più oggetti int trasparenza.
Per complicare ancola la scena ho voluto che il piano di appoggio funzionasse come uno specchio!
In questo modo si sarebbe visto anche la parte bassa delle ampolle.

Per finire ho provato a dare un effetto di profondità di campo (depth of field): per chi non sa cosa sia pensate a quando mettete a fuoco un oggetto. Tutto quello che sta dietro non è messo a fuoco, ma vi appare sfuocato. Ecco in parole povere cosa volevo ottenere.

Come di nota dall'immagine questo effetto non è che sia propriamente realizzato bene. Infatti avrei voluto fare un altro rendering con impostazioni diverse, ma dopo circa 30 minuti di render non avevo voglia di stare ad aspettare ancora.

Spero di vi piaccia!

Alla prossima. :D

Fast Modelling 5 - Book's heart

2009-07-20T23:53:00.008+02:00

Oggi mi giravano come pochi.
Motivo? Esame bocciato, ma questa è un'altra storia di cui non voglio parlare qua per non appestarvi troppo...

Comunque, dopo essermi sfogato, ho detto "abbiamo il piccio nuovo, facciamolo lavorare.... dè" (il dè in fondo ci sta sempre bene! :P)

Ma fare cosa?
Cosa si potrebbe fare di bellino e divertente?

Complice il fatto che sono stato 4 giorni ad solo a Pisa a fracassarmi i così detti, e avendo quindi molto tempo per pensare a tutto e di più (cosa che alle volte odio!), e complice anche le brevi meditazioni che ho fatto (anche quelle dovrei smettere mi sa, più si scava peggio è -.-)... insomma sta di fatto che con la malinconia che mi è presa mi è tornata alla mente una foto che vidi tempo fa su Deviant Art.

La foto consisteva in un anello messo in equilibrio su un libro aperto, con una luce alle spalle...
Bella roba direte voi!
Invece vi posso dire che come immagine è molto bella :)

Io non contento ci ho messo pure una sfera tanto per complicarmi un po' la vita XD
Come si può vedere qua la modellazione è presente solo di nome! Fare una sfera, un anello, un qualcosa che assomiglia ad un libro non è che sia un impegno gravoso...
Ma andiamo avanti va!

Quello che veramente mi interessava era il rendering di questa scena, e come potete capire quello sopra era solo una prova ^^
Dopo svariate prove, quello che ho ottenuto è stato questo!
Nella prima immagine c'è una sola luce, alle "spalle" della sfera (si potrà dire le spalle della sfera? XD), mentre nella seconda le luci sono 3, una alla destra e una alla sinistra della sfera.
Come potete vedere con le ombre proiettate hanno una forma particolare!
Scommetto che non ci avevate pensato eh ^__^

Bè come esercizio non è che fosse complicatissimo.
Volevo solo fare qualche prova con le luci (per la cronaca: le tre luci sono di tipo Spot, per capirci meglio come se fossero proiettate da una torcia), e giocare un po' sulle ombre e trasparenze!

Spero vi piaccia come immagine! :)

Come sempre sentitevi liberi di commentare o di proporre miglioramenti!

Alla prossima gente :D

Windows 7

2009-07-17T18:51:00.017+02:00

Cominciamo a dire qualche cosina, e dare le prime impressioni su questo nuovo SO.
Premetto che fino a quando non ho cambiato portatile ho sempre usato XP (ed Ubunto per l'università, ma questa è un'altra cosa).
Quindi pensavo di trovarmi maluccio con win7...

Sul portatile come accade oramai c'era installato Windows Vista... anche se da come andava mi pareva che alla Microsoft abbiano avuto più che altro una grande sVista!
Cioè lento, si bloccava per il trasferimento dei file, poi di default chiede ogni volta la conferma per installare o anche solo copiare un file...
Poi alcune cose sono veramente fatte da cani: per riuscire a raggiungere le proprietà per la configurazione della scheda di rete e mettere un cavolo di indirizzo IP statico si deve fare i salti mortali!

Dove diavolo è finita la semplicità di XP?
Secondo me come è vietato guidare sotto l'effetto dell'alchool o degli stupefacenti dovrebbero pure vietare di programmarci!

Quindi cosa ho fatto?
Mi sono scaricato la ISO di Win7, burnata ed installata.

Prima nota positiva: un partition manager fatto bene!
Per non parlare del fatto che l'installazione è velocissima! Ci mette meno di XP (ok che sono diventati più veloci i pc ^^).

Dopo l'installazione ci vuole un po' per prendere la mano... almeno a me che non ho usato Vista (da cui / ha breso la sua base).
Alcune icoone e funzioni sono state spostate (per esempio il tasto per visualizzare il desktop ora si trova nell'angolo in basso a destra! Che fatica a trovarlo XD).
Prima cosa che si nota: boot velocissimo e sistema stabile e veloce, ultra reattivo!
E' tutto il giorno che è acceso, installa, faccio i benchmark, provo e riprovo e non si è piantato mai una volta!
MAI un rallentamento, un accenno a prendere fiato!

Anche l'aspetto grafico è curato e carino.
Poi anche Areo, che sinceramente pensavo peso ed inutile, è comodo e veloce, e non cunsuma eccesive risorse: se non sapessi che è attivo non me ne accorgerei nemmeno!
Per alcuni effetti mi ricorda molto le ultime distro di Linux, con tutti quegli strani effettini.

Altre note?
Gestione dei programmi veramente buona.
Ho provato a fare dei render che feci tempo fa sul vecchio portatile, e ora il tempo di resa è circa 1/10 o meno di quello precedente (merito anche del processore molto più potente, ma anche il SO operativo aiuta, dato che 7 ha buona gestione della memoria!).
Addirittura sono riuscito a fare un render che prima non sarei riuscito a fare!
Alta risoluzione, anti-Aliasing ed altri effetti (solo per appesantire, tanto la differenza ad occhio si notava poco), e devo dire che è andata bene!
Ci ha messo 20 minuti per renderizzare il tutto, ma nel frattempo navigavo, scrivevo, ascoltavo musica, vedevo un filmato su youTube, installavo AdobeReader, etc... e non si è minimamente impensierito!
Andato avanti fino alla fine senza un tentennamento!

Ho trovato un'unica pecca, e cioè che come vista occupa circa 1 gB di ram...
Ma che ci vogliamo fare, non esistono più i SO che partono in 200 MB di ram ^^

Che dire gente!
Accorrete ed installate!

Ecco i 2 render di prova che ho fatto!

Dimensione: 1800x2400 px
Tempo di resa: circa 80 secondi - contro gli oltre 10 minuti sul vecchi portatile

Dimensione: 2000x2000
Tempo di resa: 20 minuti circa - contro un spegnimento a stronco all'incirca dopo 2 minuti sul vecchio portatile.

Ci sentiamo presto!
Alla prossima!

Si riparte!

2009-07-17T15:38:00.001+02:00

Nuovo portatile preso!
Funziona benone, è una potenza!

Si può quindi ricominciare a lavoricchiare... anche se ora c'è da reinstallare ogni cosa...
Con tanta calma di farà tutto! Forza e coraggio!

Ancora poco

2009-07-16T07:57:00.002+02:00

Finalmente ho comprato un nuovo portatile.
Questo significa che tra poco potrò di nuovo tornare a lavorare.
Datemi solo il tempo di installare i sistemi operativi che mi servono e i vari programmi.

A presto!

Una notizia positiva

2009-07-01T19:34:00.002+02:00

Sono riuscito a recuperare i dati dall'HD del mio portatile.
Almeno una cosa positiva in questi giorni...
Ora siamo alla ricerca di qualche offerta per un portatile...
Speriamo di non svenarci troppo!

Momentanea assenza forzata

2009-06-26T23:03:00.002+02:00

Come dice il titolo mi tocca momentaneamente sospendere la pubblicazione di contenuti... Potrò semmai postare qualche lamentazione o riflessione, ma per ora niente più lavori...
Ho dei problemi con il portatile sul quale ho tutti i dati, e mannaggia a me ancora non sono riuscito a recuperarli.
Il povero pc sembra abbia tirato le cuoia, anche se io spero di riscire a ripararlo più che comprarlo nuovo.

A più presto possibile con (spero buone) nuove!

Fast Modelling 4 - Bottiglia in LightWave

2009-06-21T00:44:00.005+02:00

Un altra piccola prova per esercitarsi con LW.
Ogni tanto mi piglia il pazzo e mi ci butto così che ci posso fare!

Questa volta è toccato un piccolo esercizio di rendering.
Volevo provare a fare un render un po' più realistico, non fotorealistico ma un po' più somigliate alla realtà.
Ho fatto una piccola bottiglia, un piano, qualche sfera messa a caso (dentro la bottiglia)... Insomma una scenetta semplice semplice.

La difficoltà era nel fare un buon render...
Dopo aver applicato un materiale di tipo vitreo agli oggetti mi sono sbizzarrito in varie prove di resa.
Non facile devo dire, quando ci si trova davanti a tutte quelle impostazioni, valori da cambiare, provare, etc.

Poi, cercando anche tra i vari tutorial che avevo raccolto, mi sono imbattuto in uno sull'HDRI.
Poche semplici impostazioni, caricando un'immagine per HDRI e usandola nell'ImageWorld.
Un render di prova senza nemmeno apportare modifiche alla scena o altro e il risultato è stato questo!
Mi piace come effetto!
Controlla "da solo" le riflessioni, la luminosità, etc...
Credo che sia così almeno, devo studiarlo meglio e fare altre prove.

Lo so, avete delle domande:
- Come si sono entrate le sfere dato che sono troppo grandi per poter essere infilate dal foro della bottiglia?
- cosa conteneva la bottiglia e chi si è scolato il contenuto?
Eh... I misteri della vita :D

Alla prossima, sperando che non sia una bottigia...

LightWave - Cartoon soldier

2009-06-18T20:59:00.011+02:00

Un altro lavoro è finito...
O almeno è finito per me. Oramai è entrato nella parte della mia mente che fa parte di quelle cose che non verranno più toccate.

Mi sono deciso oggi, a mettermi a fare un po' di prove per il rendering.
Prova qua, prova la (e tra un render e l'altro studiavo per l'esame) sono riuscito a raggiungere un risultato soddisfacente (almeno per me e per la voglia che avevo di completare il tutto).

Ho tolto poi gli elementi strani, che facevan tanto androide o simili, che avevo aggiunto precedentemente.
Potevo fare di meglio lo so:
- la pelle non è proprio venuta benissimo
- potevo creare una barba/capelli/sopracciglia migliori
- rendere migliore l'espressione
- per li occhiali idem come sopra

Però come ho detto stavo finendo la voglia di lavorarci, considerando poi che il pc non ce la fa a renderizzare bene scene troppo sofisticate (con conseguente spegnimento a stronco del computer, seguito da eresie lanciate da parte mia).

Ecco poi a voi una vista totale del personaggio e del gatling:
Per essere in stile cartoon non mi pare poi tanto male.
Lo so cosa state pensando: si lo so che ha la pancia!
Ci stava bene la pancetta :P

Come sempre sono "poco soddisfatto" perchè so che volendo potrei fare molo meglio.
Ma dato il periodo strano, e tanti altri motivi, non posso lamentarmi troppo...

Spero vi piaccia!

Alla prossima!

Fast Modelling 3 - Mano in LightWave

2009-06-17T13:22:00.019+02:00

Vi capita mai di avere un mal di testa tale non potervci concentrare?
E per quanto provate a non persarci, il dolore martellante continua incessante a rompervi le scatole?

A me capita spesso in questo periodo!
Ma oggi, anche se mi ha costretto ad abbandonare lo studio, mi sono messo all'opera cercando di distrarmi un poco.
Il lavoro è fatto sotto l'effetto di una forte emicrania, quindi potrebbe non essere venuto fuori benissimo...

Sempre per la serie sketch veloci, fatti così su due piedi, ho deciso oggi di dedicarmi ad uno di quelli che riconosco essere uno dei miei punti deboli: le mani!
Mi riescono sempre male a me le mani...
Anche se di solito quando vado a modellare una mano arrivo che ho già il braccio fatto, e quindi non mi ritrovo più di tanto a collegare bene i due arti.
Stavolta ho deciso di affrontare il problema dalla parte opposta!
Sono partito quindi dalla falangetta del medio, cioè questa:
Accidenti... ho creato il mio primo moncherino...
Bhe è abbastanza semplice come pezzo.

Poi la prosecuzione del lavoro è andata abbastanza spedita:
prima ho dovuto creare il resto del dito, cosa immediata

e dato che non sono masochista, per la creazione delle altre dita ho clonato quello che avevo già fatto, e li ho rimpiccioliti in modo opportuno.

Dopo aver clonato le dita, si è cominciato a creare la mano vera e propria.

Il primo ostacolo che ho avuto è stato la creazione del pollice e la sua attacatura alla mano:
ho riusato la falange creata per il medio, per poi attaccarla alla mano.

Dopo questa operazione mi è bastato completare il tutto creado nuovi poligoni e aggiustando la loro posizione.

Un po' di suddivisione per arrotondare il tutto e il gioco è fatto.

Dopo la modellazione vera e propria è saltato fuori il vero ostacolo di tutto questo lavoro, e cioè creare lo scheletro della mano e "riggare" il tutto.
Una sfida abbastanza ardua, dato che ci capisco poco...
Non mi sono dato per vinto e ho cominciato col crearmi le varie mappe da associare alle ossa, le ossa, la gerarchia, gli oggetti per IK (la cinematica inversa) e il settaggio dei vari parametri.
Dopo un po' di invocazioni di Divinità antiche e pagane, con conseguente tremolio della stanza (forse più dovuto al mal di testa che alle eresie...) sno riuscito a fare un lavoro decente con lo scheletro.
Non sono completamente soddisfatto, dato che ci sono delle cose che non tornano, come piegatura dei poligoni che non vanno come devono andare, etc.
Tutto sommato però è un passo avanti per me: ho assimilato abbastanza bene il meccanismo per la IK.
Ecco i render finali di tutto ciò

Tempo di completamento di tutto il lavoro: circa 2 ore (e tante eresie quando le ossa non vogliono muoversi come gli dici tu!)

Spero vi piaccia :D
Alla prossima!

Work In Progress 2

2009-06-16T10:00:00.000+02:00

Ho trovato il tempo di portare un poco avanti il modello che avevo cominciato qualche tempo fa, e che era rimasto fermo per mancaza di ispirazione.
Oggi per una qualche strana coincidenza stellare e/o planetaria ho trovato un pizzico di ispirazione!

Sono partito da quello che avevo lasciato qua e qua.

Quello che ho fatto è stato completare il Gatling per dargli una forma un poco più consona alle mie esigenze. Dopo un po' di prove, di posizionamento dei manici, della forma, etc ho ottenuto questo:
Per ora sono abbastanza soddisfatto, sia della forma che della posizione dei componenti.
Ciò non toglie che possa sempre fare qualche modifica in futuro se lo riterrò necessario.

Ho poi ripreso in mano quell'omone rimasto li imbambolato.
Ho dovuto studiarmi un po' di IK (Inverse Kinematics, cinematica inversa), un sistema con il quale posso muovere le ossa del mio personaggio posizionando le sole estremità invece che posizionare a mano tutte le singole ossa.
Ho ancora parecchio da studiarci, ma intanto ho capito il concetto e questo è già un passo avanti.
Dopo aver creato lo scheletro, aver messo assieme il Gating e il personaggio, aver posizionato il tutto in modo più o meno decente ho fatto un render di prova.
Ho fatto qualche piccola aggiunta all'uomo, tanto per vedere come si comportavano in presenza dello scheletro, aggiunte che per ora ho deciso di lasciare dato che non ci stanno malissimo, e potrebbe portarmi a creare modificare il personaggio.

Spero vi piaccia.
Certo ancora è da completare ma mi pare di aver fatto qualche passo in avanti!

A presto con altre nuove, sempre che non passi un pezzo senza avere ispirazione!

Scriviamo bene il codice!

2009-06-12T22:17:00.004+02:00

Il lavoro del programmatore è un lavoro faticoso.
Devi strutturare bene il progetto su cui stai lavorando e che devi realizzare.
Dopo una fase di progettazione si passa alla realizzazione.
Quando tuttu funziona e consegni il lavoro sei soddisfatto e pensi "bene ora non ci voglio rimettere le mani".

Ah ma è qui che mi casca l'asino.
(poi perchè caschi l'asino non lo so... poraccio tutti con lui ce l'hanno...)

Si sa, è impossibile ricordarsi tutto quello che si fa, ricordarsi tutte le cose che abbiamo scritto o simili.
Ecco, questo per un programmatore è una cosa orribile.

Mi sta capitando in questo periodo di dover rileggere per motivi universitari, che non sto qua a spiegare, del codice che ho scritto circa 3 mesi fa oramai.
Si tratta di alcuni file contenenti del codice C.
Allora già io sono stronzo e commento poco il codice, e mi accorco ora che dovrei aggiunge più commenti.
Il C è un linguaggio potente, ci puoi fare molte cose, ma se scrivi roba troppo compatta poi rischi di perdere 1 minuto a capire quello che fanno 3 righe di codice che hai scritto tu stesso.
Oppure non vedi un "!" in una condizione e quindi ti cambia il significato del controllo che stai facendo.

E il più delle volte sono delle cavolate quelle che creano più problemi di comprensione!

Altro esempio, ho riletto verso Febbraio il listato di un progetto scritto in C che consegnai verso Ottobre...
Piangevo per gli orrori che avevo commesso!
Mi chiesi pure come aveva fatto il professore a considerare passabile una cosa simile (io mi sarei stroncato da solo). Puntatori non controllati, accesso ad aree di memoria ch forse potevano non esistre... Insomma un incubo!

Dopo solo 6 mesi circa era completamente cambiato il mio modo di vedere ed affrontare le cose.
Ho paura di come potrei essere tra qualche anno...

A parte che la mentalità e le conoscenze di una persona cambiano, e per chi prgramma vuol dire anceh cambiare stile di programmazione, di scrittura e di approccio verso i problemi che gli vengono posti.

La morale?
Scrivete bene il vostro codice, commentate più che potete, e sopratutto sperate e pregate di non doverlo rileggere tutto completamente... è una cura per l'insonnia da paura.

Fast Modelling 2 - Gatling in LightWave

2009-06-11T09:45:00.005+02:00

Ogni tanto mi piglia il pazzo, e comincio a modellare alla "do coio coio".
Qualche volta va bene ed esce fuori qualcosa di decente, qualche volta no.

Questa volta mi è andata bene.
Cioè si può fare molto meglio lo so, ma per un qualcosa fatto in fretta e furia, mentre guardavo un filmaccio alla tv (mi pare Baby Birba o qualcosa del genere...ma quante volte lo avranno passato O_O), e mentre studicchiavo un po' (cioè ogni tanto staccavo la testa dal libro e facevo qualche modifica al modello) non mi posso lamentare più di tanto.
Credo di averci messo si e no due ore (comprese tutte le distrazioni eh XD)
Ecco a voi:
Questa volta ho cercato di fare un Gatling. Mi hanno sempre ispirato violenza e potenza come armi. Certo ca migliorato, ma credo ci si possa tirar fuori qualcosa di bello :D
Se poi riesco credo che unirò questo modello a quello del bestione che ho fatto qualche giorno fa...
Chissà cosa potrei creare :P

Alla prossima!

Work In Progress 1

2009-06-08T12:08:00.003+02:00

La mente è capace di partorire delle cose veramente strane.
Alle volte mi capita di avere in mente un'idea precisa per un modello 3D e di non riuscire a realizzarlo.
Ma il più delle volte riesco a tirare fuori i lavori più strani e meglio fatti quando parto da qualcosa di indefinito e vago.

Vi ricordate il testo del Fast Modelling 1?
Bè mica potevo lasciare quella povera testa a galleggiare per aria no?
Lavoricchiando un po' questo è il risultato
Credo di dover fare qualche modifica anatomica al collo, altrimenti per il resto sono abbastanza soddisfatto.
La vaga idea che avevo in mente adesso sta prendendo una forma più dettagliata, quindi ora non mi resta che realizzarla in pratica, sperando di ottenere qualcosa di buono.
Spero vi piaccia.

Se qualcosa non vi torna o avete modifiche da proporre non fatevi problemi a dire quello che pensate!

Alla prossima! :)

Fast Modelling 1 - Testa in LightWave

2009-06-03T21:35:00.004+02:00

C'è chi fa degli sketch su un foglio di carta.
C'è chi gli piace scattare delle foto.
Bhe io non ho ne le capacità per fare un bel disegno, ne ho la possibilità di fare delle foto quando mi pare.

Diciamo che questi sono i miei sketch.
Ogni tanto mi capita di da un'occhiata alla cartella dove ho buttato le centinaia di immagini che ho raccolto in tanto tempo.
Ci sono le cose più disparate, le più strane.
Ogni tanto piglio spunto da qualcosa che è li dentro per tirarne fuori qualche lavoretto.
Ecco quello che è uscito oggi:

Ci avrò messo circa 2 ore e mezzo a fare il tutto. Proprio come uno sketch, solo un po' più lento.

Spero vi piaccia.

Alla prossima!

Gunblade Rebirth - The end

2009-06-02T11:00:00.003+02:00

Finalmete il lavoro è giunto a termine.
Non ci posso credere neanche io ma invece è così.
E' completo e pronto per la produzione e vendita di massa!

Battute a parte il Gunblade è finito.
Come avevo detto avevo ancora da aggiungere dei particolari, dei dettagli per completare il lavoro.
Una cosa che ho voluto realizzare è stata la testa del Griever appesa alla catenina. La testa originale che c'era non mi piaceva più di tanto, però ricordavo che il Griever raffigurato nella collana (che ho :P) aveva una forma diversa, e che aveva una parte che somigliava ad una croce.
Dopo aver cercato il disegno sul Web, e dopo un po' di lavoro ecco a voi il Griever!
Non ho voluto mettere troppi dettagli, anche perchè ce ne sarebbero tanti da mettere, ma ho preferito non esagerare. Già il mio povero pc ha fatto fatica a renderizzare queste immagini :(
Mi si è anche spento diverse volte durante la fase di rendering (con bestemmie allegate da parte mia, se considerate che un render non mi durava mai meno di 10 minuti...)

Dopo il Griever sono passato ai proiettili nel caricatore.
Per questi è stato facile, in fondo sono solo dei cilindri ^_^

E' stato più complicato impostare il render dei bossoli che crearli.
Ma non pensate che faccia le cose a metà...
I proiettili sono completi! Bossoli e testa dei proiettili! Bossoli dorati, proiettili cromati!

Bè, che dire ora...
Il lavoro è finito. Mi sono divertito. H avuto una scusa per rimettere mano su un programma che per motivi di studio non riusavo da molto tempo.
Ho bestemmiato contro il mio portatile per il fatto che non ce la faceva a fare il rendering. Infatti se notate qualche immagine non ha l'antialiasing.
E ora vi lascio con le ultime 2 immagini!

Spero vi piacciano :)

Per l'immagine in alta risoluzione: Gunblade

Se avete qualche altra idea da propormi sono qua.

Ringrazio:
Angie, che dandomi dello sfaticato mi ha spinto a lavorare di nuovo!
Ryuk, che mi ha dato l'idea iniziale di rifare il Gunblade!
Mio cugino, che giocando ora a FF8 mi ha assillato con le sue domande e mi ha spinto ancora di più a lavorare!
William Vaughan, per i suoi tutorial su Lightwave, i quali sono una fonte infinita di trucchi e insegnamenti!

Alla prossima! :D