// Generiamo un array di float che sono le altezze (y) dei punti di

 controllo.

      var tmp =

        Enumerable.Range(0, controlPoints.Width)

        // i ∈[0,controlPoints.Width-1]

        .Select(i => i / (float)controlPoints.Width)

        // x ∈[0,1]

        .Select(x => sin(-4.0f * t + 32.0f * pi * sigmoid(x + 0.5f) * x)

          * 0.1f + 0.5f)

        // y é l'altezza di un punto di controllo. La convertiamo in formato

  integrale.

        .Select(y => (UInt16)(y * (UInt16.MaxValue - 1)))

        .ToArray();

      // Salviamo l'array di altezze nella texture.

      controlPoints.SetData<UInt16>(tmp);

      // Carichiamo la texture di sfondo.

      var background = Content.Load<Texture2D>("background");

      /// Disegnamo la texture di sfondo. Questa operazione non dipende in alcun

 modo da come poi disegneremo il serpente.

      spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Immediate,

                  SaveStateMode.SaveState);

      spriteBatch.Draw(background, new Rectangle(0, 0, 800, 600), Color.White);

      spriteBatch.End();

      /// Disegnamo il serpente con il nostro shader in alpha blending sulla

 scena precedente. L'operazione di disegno genera un serpente che passa

 per i punti di controllo della texture "controlPoints".

      new Vector3[] { new Vector3(0, 1, 1}

        .Select((color, index) => new {color, index})

        .ToList().ForEach(snake =>

        {

          fx.Parameters["SnakeColor"].SetValue(snake.color);

          spriteBatch.Begin(SpriteBlendMode.AlphaBlend,

                        SpriteSortMode.Immediate, SaveStateMode.SaveState);

          fx.Begin();

          pass(0, p => p.Begin());

          spriteBatch.Draw(controlPoints, new Rectangle(0, 100 + 100 *

                              snake.index, 800, 400), Color.White);

          pass(0, p => p.End());

          fx.End();

          spriteBatch.End();

        });

      base.Draw(gameTime);

}

fx.Begin();

pass(0, p => p.Begin());

fx.End();

Effect fx = null;

Texture2D controlPoints;

const int numControlPoints = 256;

protected override void LoadContent()

{

  /// Costruiamo il renderer 2D.

  spriteBatch = new SpriteBatch(GraphicsDevice);

  /// Costruiamo la texture di control points, in cui carichiamo interi

  /// unsigned a 16 bit. La texture é una matrice numControlPoints × 1,

  /// cioè 256 colonne e una riga.

  controlPoints = new Texture2D(GraphicsDevice, numControlPoints, 1, 1,

        TextureUsage.None, SurfaceFormat.Luminance16);

  // Carichiamo lo shader HLSL.

fx = Content.Load<Effect>("snake shader");

}

protected override void Draw(GameTime gameTime)

{

      //Resettiamo lo sfondo dell'applicazione ad azzurro.

      graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

      // Alcuni piccoli helper trigonometrici e non.

      Func<float, float> sin = x => (float)Math.Sin((double)x);

      Func<float, float> sigmoid = x =>

                             (float)MathHelper.SmoothStep(0.5f, 0.1f, x);

      var pi = (float)Math.PI;

      // Da quanti secondi l'applicazione é in esecuzione?

      var t = (float)gameTime.TotalGameTime.TotalSeconds;

      // Helper di attivazione/disattivazione di un passo dello shader HLSL.

      Action<int, Action<EffectPass>> pass = (i, a) =>

                                                a(fx.CurrentTechnique.Passes[i]);

Action<int, Action<EffectPass>> pass=(i, a) => a(fx.CurrentTechnique.Passes[i]);

fx.Begin();

fx.CurrentTechnique.Passes[0].Begin();

//…code…

fx.CurrentTechnique.Passes[0].End();

fx.End();

fx.Begin();

pass(0, p => p.Begin());

//…code…

pass(0, p => p.End());

fx.End();

sampler ControlPoints : register(s0) = sampler_state

{

  MipFilter = LINEAR;

  MagFilter = LINEAR;

  MinFilter = LINEAR;

  AddressU = CLAMP;

  AddressV = CLAMP;

};

AddressU = CLAMP; // punto di controllo di partenza

AddressV = CLAMP; // punto di controllo di arrivo

… : register(s0)…

float4 PixelShaderFunction(float2 input : TEXCOORD0) : COLOR0

{

  float cp;

  cp = tex2D(ControlPoints, float2(input.x, 0.0f));

  float alpha = pow(saturate(1.0f - abs(input.y - cp)), 32.0f);

  return float4(SnakeColor.xyz,alpha);

}

  cp = tex2D(ControlPoints, float2(input.x, 0.0f));

  float alpha = pow(saturate(1.0f - abs(input.y - cp)), 32.0f);

technique Technique1

{

    pass Pass1

    {

        PixelShader = compile ps_2_0 PixelShaderFunction();

    }

}

By Davide Luzzu, Webcast di Giuseppe Maggiore

Camera e Input

Abstract

Come la maggior parte di voi avrà capito Xna è un’avanzatissima piattaforma per sviluppare videogiochi. Quello che ci si aspetterebbe da un videogioco è che fosse interattivo; se così non fosse la sarebbe un’animazione! Dopo aver constatato questa “sottile” differenza, i più arguti tra i lettori, noteranno anche che finora abbiamo creato un mondo virtuale, in cui eravamo impossibilitati nel movimento, cioè non potevamo navigare nel mondo virtuale. Ma diremo di più. Non si poteva proprio interagire in alcun modo con la scena 3D!

La base dell’interazione risiede nell’abilitare l’input da dispositivi come tastiera, gamepad, joystick, o mouse. Ogni volta che l’applicazione riceve un input da uno di questi dispositivi, dovrà essere in grado di analizzare l’input ed eseguire una azione conseguente. L’analisi viene effettuata automaticamente da Xna, ed al programmatore è lasciato il compito di definire l’azione derivante dall’input.

In un gioco 3D, come si diceva poc’anzi, è fondamentale potersi muovere all’interno della scena, cioè la nostra “telecamera” deve essere “mobile”. Tale telecamera è manovrata manipolando la matrice View.

Una affermazione che potrà sembrare strana è che in realtà quando ci si muove all’interno di un mondo 3D, non è il player che si sposta, ma il mondo intero! In parole povere il player resta fermo e il mondo si muove in senso contrario all’input ricevuto, così da dare l’impressione di muoversi nella direzione desiderata; quando ad esempio il player preme il tasto direzionale “freccia destra” il mondo si muoverà verso sinistra, e così via. E’ un po’ come svitare una lampadina facendo ruotare l’intero palazzo!

In questo articolo presentiamo quindi i principi fondamentali per consentire la navigazione, e l’interazione in generale, all’interno di un mondo virtuale.

Struttura di un nuovo progetto

Per la creazione di questo progetto ci baseremo su “Models”, l’articolo per la gestione dei modelli.

Info aggiuntive

Per quanto riguarda i dispositivi di input sono necessarie alcune precisazioni.

Xna Game Studio 3.0 è una piattaforma per lo sviluppo di videogiochi su XBox 360 e Windows Platform, e supporta 3 dispositivi di base: tastiera generica, mouse generico e gamepad XBox. Salvo poche eccezioni altri gamepad non funzioneranno sulle vostre applicazioni. Tuttavia su internet esistono svariate librerie di supporto gratuite, per integrare differenti gamepad da quello XBox 360.
 
 
 

Implementazione

Riguardo al controllo della visuale del player Xna 3.0 offre una soluzione davvero semplice ed intuitiva. Prima però è necessario introdurre una piccola nota di teoria; esistono tre differenti movimenti rigidi che la telecamera può compiere per riprodurre i movimenti che farebbe la testa del giocatore per guardarsi attorno: Yaw, Pitch e Roll.

o  Yaw è il movimento di rotazione della testa che compiamo quando ad esempio guardiamo a destra e sinistra prima di attraversare la strada.

o  Pitch è il movimento di rotazione che compiremmo se, guardando dritti di fronte a noi, inclinassimo la testa avvicinandola ad una spalla.

·     Roll è il movimento di rotazione che compiamo quando guardiamo in alto e in basso

Un’interessante digressione sull’argomento lo potete trovare su  http://en.wikipedia.org/wiki/Yaw,_pitch,_and_roll

Per controllare queste tre rotazioni ci serviamo di un quaternione, che non è altro che una matrice 4x4 ottimizzata per alcuni calcoli 3D. Il quaternione è creato attraverso il metodo statico CreateFromYawPitchRoll(yaw, pitch, roll) al quale passiamo in ingresso le nostre rotazioni.

Abbiamo accennato al fatto che il mondo si muove così come abbiamo immaginato di svitare una lampadina: al contrario! Il calcolo di tale movimento lo eseguiamo in una matrice che controllerà la nostra vista. Definiamo innanzitutto la posizione del vettore di vista e ne creiamo la traslazione inversa con

e lo moltiplichiamo per l’inverso ( il coniugato ) della rotazione data dal quaternione “eyeRotation” in questo modo:

Le direttive del movimento in base all’input vanno codificate nel metodo apposito Update, di cui eseguiamo l’override.

Il metodo GetState() ci consente di recuperare le informazioni dello stato del dispositivo di input, sia esso Keyboard o GamePad. Nel nostro caso abbiamo salvato lo stato in una variabile che ci servirà per controllare la pressione dei tasti direzionali della tastiera.

La nostra variabile “keyboardState” contiene un metodo “IsKeyDown(int)” al quale passeremo il tipo di tasto (sottoforma di intero) che vogliamo controllare.

L’ultimo passaggio prevede il movimento consono all’azione del tasto premuto.

Buon divertimento!

By Davide Luzzu- Webcast di Giuseppe Maggiore

Abstract

Tutti gli oggetti visuali nel mondo virtuale 3D sono composti da triangoli. Tali oggetti visuali possono essere più o meno complessi, e tale complessità implica un numero considerevole di triangoli, anche svariate centinaia di migliaia. E’ comprensibile che posizionare manualmente ad uno ad uno tutti i triangoli potrebbe essere terribilmente noioso, se non impraticabile!

Ecco dunque la necessità di possedere uno strumento nelle librerie di sviluppo che ci renda possibile il caricamento di modelli 3D, creati con software appositi. Tale strumento viene genericamente chiamato Loader (caricatore), ed esegue una azione di Load (caricamento).

XNA offre un’interessante opportunità per compiere azioni di Load, infatti, consente il caricamento e l’interazione con i modelli 3D attraverso poche righe di codice.

In questo articolo viene dunque presentato il caricamento da file di modelli tridimensionali, la loro visualizzazione all’interno della scena ed infine il posizionamento nel mondo virtuale.

Struttura di un nuovo progetto

Ogni progetto XNA 3.0 possiede una sotto-struttura logica (cioè dove mettere i dati), chiamata Content, nella quale dovremo copiare i dati dei modelli. La copia può avvenire attraverso una semplice operazione di dragging.

E’ importante inserire i dati nella struttura apposita Content, poiché essa contiene delle References statiche alle impostazioni di libreria, ed esse ci consentiranno, senza alcuno sforzo, il caricamento dei dati (audio, effetti, textures…), utili al nostro progetto.

Info aggiuntive

Una delle caratteristiche più interessanti relative all’import e alla visualizzazione dei modelli in XNA 3.0, è il fatto che la compilazione dei modelli è incrementale. Per compilazione intendiamo l’elaborazione della struttura dei modelli, per crearne una rappresentazione nel nostro ambiente virtuale. Con incrementale indichiamo il principio per cui, una volta compilati, le successive elaborazioni dell’ambiente virtuale saranno più veloci, poiché la struttura non deve essere rivisitata completamente. E’ una caratteristica di enorme importanza, poiché fa risparmiare una quantità enorme di tempo in fase di creazione e  debugging del nostro mondo virtuale.

Implementazione

La parte principale del caricamento dei modelli è contenuta nel metodo LoadContent creato di default dall’applicazione.

In questa porzione di codice abbiamo inizialmente creato due variabili di tipo Model, le quali conterranno i dati dei nostri modelli.

L’istanziamento delle variabili imperialDestroyer e rebelCruiser è decisamente semplice: si fa riferimento ad una classe Content che contiene un metodo Load ad accesso statico. Tale metodo statico Load riceve in input una stringa che designa il percorso di accesso al modello (che deve essere indicato senza l’estensione).

Da notare che Load è parametrizzato con un tipo Model; ciò indica all’applicazione che il caricamento, che si sta tentando di effettuare, dovrà rendere un Model.

Questo metodo Draw, da noi definito, prende in ingresso due parametri: Model e Matrix. Il parametro di tipo Model indica il modello caricato a cui applicare le trasformazioni affini, contenute nel parametro di tipo Matrix.

In aggiunta alle trasformazioni affini, applichiamo anche delle luci, per rendere più realistica la percezione del modello nel mondo virtuale.

Senza addentrarci troppo nell’argomento luci, potremmo dire genericamente che l’assenza di luci dà una sensazione di “finto” nella visualizzazione degli oggetti visuali.

Riguardo alle luci utilizzate in questo tutorial notiamo che viene abilitata un'unica luce direzionale, con un colore (diffuse color), ed un colore Violet di risposta alla luce sugli oggetti (specular color).

Trasformazioni affini e luci sono contenuti nell’interfaccia generica BasicEffect, che applichiamo effettuando un casting esplicito:

Il metodo Draw, da noi definito, contiene due foreach annidati per cui:

• quello esterno scorre tutte le mesh contenute nel modello,
• quello interno lo useremo per applicare gli Effect ad ogni mesh.

La complessità computazionale di tale esecuzione è O(n²).

Una delle parti più interessanti in questa porzione di codice è l’utilizzo delle matrici World, View e Projection.

·               World è la matrice che rappresenta le coordinate di traslazione e rotazione del modello rispetto al mondo virtuale ( world coordinates ). Esiste una matrice world per ogni modello, così da poterli controllare singolarmente.

·               View   è la matrice che indica la proiezione di vista, in altre parole rappresenta la telecamera attraverso la quale noi osserviamo il mondo virtuale. Al momento abbiamo inserito una sola View, ma in giochi multiplayer possono coesistere più View, una per ogni giocatore.

·               Projection è la matrice che rappresenta le caratteristiche dell’obiettivo della nostra telecamera. Le impostazioni base di questo obiettivo sono: il suo angolo di apertura, il rapporto altezza/larghezza, il front clip plane (cioè il punto di inizio del focus), il back clip plane (cioè il punto di fine del focus). Back e front clip plane indicano, in altre parole, dove noi iniziamo a vedere (ad esempio 0,1 cm dal nostro occhio), e sin dove si spinge la nostra visuale (ad esempio 3 km, 10 km ecc…).

Draw è il metodo di cui eseguiamo l’override per disegnare gli oggetti visuali nella scena. In questo caso contiene poche righe di codice, poiché demandiamo tutto ad un altro metodo Draw, descritto in precedenza.

Al metodo Draw, da noi definito, passiamo dunque il modello e la matrice World, dopodiché disegniamo la scena chiamando:

che si occupa di lanciare l’implementazione di default del metodo Draw fatta da Xna e che si occupa di effettuare tutte le operazioni “standard” di finalizzazionedel disegno della scena in DirectX.