English Version

Ciao, sono Giulia Costantini e in questo tutorial vi verrà mostrato come mettere una console Python nel vostro gioco. Perché Python? Semplice, perché è uno dei linguaggio più potenti, flessibili e facili da usare che esistono.

La console Python è in realtà un game component (guardate il nostro precedente tutorial sui components se non sapete cos'è un component). Con questa console, possiamo modificare i nostri oggetti in-game senza bisogno di ricompilare, modificare i file di configurazione, eccetera... possiamo anche leggere ed eseguire dinamicamente script Python a tempo d'esecuzione!

Nel videotutorial Giuseppe Maggiore (tradotto in italiano da Alessandro Piva) vi spiegherà come potete "inserire" Python nel vostro progetto e come potete creare il Python GameComponent.

Come vedrete nel webcast, saremo in grado di modificare gli oggetti publici nel gioco tramite la console Python: per esempio, potremmo azzerare la lista di droni e tutti i droni sparirebbero dallo schermo! Poi, potremmo aggiungere qualche altro drone (la lista dei droni è accessibile come pubblica dalla variabile globale "game") ed ecco: nuovi droni apparirebbero!

La console appare così:

Qui potete trovare il codice sorgente utilizzato in questo tutorial. Buon divertimento!

Ecco una versione a bassa risoluzione del videotutorial:

Giulia Costantini

P.S.: ringraziamenti speciali ad Alessandro Piva per l'idea di mettere IronPython nei nostri giochi.

English version

Ciao gente! Sono Giulia Costantini e questo tutorial riguarda i game components in XNA. I game components sono una caratteristica molto importante e utile della piattaforma XNA. Per avere servizi ordinati e riusabili nel vostro gioco, c'è bisogno di una struttura generica per questi servizi. Visto che un servizio tipicamente ha una forma standard, i GameComponents astraggono questa forma in un insieme speciale di classi XNA. I game components vi permettono di costruire ordinatamente moduli logici riusabili.

In questo videotutorial (tenuto da Giuseppe Maggiore e tradotto da Alessandro Piva), dopo aver spiegato più in dettaglio cosa sono i game components, vi verrà mostrato come esempio un semplice, eppure sempre utile, game component: un componente che scrive su schermo il frame rate sopra la scena esistente.

Potete trovare il codice sorgente del tutorial qui.

Qui potete vedere una versione a bassa risoluzione del webcast:

Buon divertimento!

Giulia Costantini

[English version]

Ciao a tutti! Io sono Giulia Costantini, e in questo tutorial vi spieghero' come fare per applicare una texture su una mesh. Se non sapete ancora cos'e' una texture, non vi preoccupate: entro la fine del tutorial saprete di tutto e di piu'!

Questo tutorial e' diviso in due parti. Nella prima parte vedremo cosa e' una texture (una immagine che possiamo applicare sugli oggetti per renderli piu' verosimili), come si puo' importare e caricare una texture in un progetto XNA e infine come applicare la texture caricata su un semplice quadrato. Il risultato che otteremo sara' di questo tipo:

Nella seconda parte del tutorial vedremo dei concetti un po' piu' avanzati: in particolare, faremo degli esperimenti con le coordinate di texture (introdotte nella prima parte) in modo da capirle meglio. Inoltre aggiungeremo alla classe BasicMesh (introdotta nel tutorial sulla geometria, ricordate?) il supporto per le textures; cosi' facendo ogni forma geometrica gestita da quella classe (quadrato, griglia, sfera, cono, cilindro) avra' le sue coordinate di texture, rendendo immediata l'applicazione di una texture.

Come al solito il codice sorgente di questo tutorial e' gia' online. Ricordatevi che siamo qui per rispondere alle vostre domande, quindi non esitate a scriverci!

Il webcast ad alta risoluzione si trova qui. Mettiamo anche un embedding dello stesso video a risoluzione piu' bassa per chi non potesse/volesse scaricare l'altro:

Detto cio'... buon webcast! Giulia Costantini

English version

Salve a tutti, sono Giuseppe Maggiore ed eccezionalmente oggi non parlero' di XNA. Capisco che questo possa lasciare perplessi (in effetti e' un blog su XNA), ma l'eccezione e' comprensibilissima. Quest'anno, infatti, mi e' capitata l'opportunita' di essere un MSP, e quindi sono sempre a caccia di materiale Microsoft interessante (e quando possibile gratuito) per offrire a studenti e docenti del mio dipartimento un motivo di interesse (o quantomeno curiosita') verso le iniziative tecnologiche della Microsoft.

Veniamo al sodo: avete mai dovuto scrivere un articolo o una tesi pieno di formule matematiche? Se si, saprete allora che LateX e' una scelta obbligata, pur essendo decisamente una delle esperienze piu' old-school e user-unfriendly che io abbia mai sperimentato. Almeno finora. In Word 2007 il sistema di editing di equazioni e' stato ristrutturato completamente, obliterando del tutto il discutibile Equation Editor che ormai ha raggiunto la versione 3.0. Questo giro troviamo un parser di un linguaggio molto stile-LateX che permette di scrivere in LateX, ma leggere matematica vera e propria (e di switchare tra vista LateX e vista matematica). Io lo trovo favoloso!

Spero di non fare la parte dell'idiota colossale (tipo che qualcosa di identico esiste che la gente usa da anni tranne io :) ), ma qui c'e' il webcast che mostra come usare questa gustosa caratteristica di Word2007!

English version

Ciao!

E' giunto il momento del nostro secondo videotutorial: questa volta lavoreremo sulle Matrici. Nella computer grafica, le matrici sono molto importanti per possono rappresentare trasformazioni che possiamo applicare ai vertici. Traslazione, rotation, scalatura, proiezione prospettiva, tutte queste operazioni possono essere fatte molto facilmente con le matrici.

Introdurremo anche il concetto di istanza di una mesh. Tutte le istanze di una mesh condividono i dati riguardanti i vertici e i triangoli, ma possono differire per posizione, colore, texture, e così via... Metteremo tutto questo in pratica scrivendo un piccolo demo; ecco uno screenshot:

Basta esitare, ecco tutti i link:

• Il webcast in inglese e il webcast in italiano
• Il codice sorgente del demo
• I code snippets utilizzati nel demo, con le istruzioni per utilizzarli

Potete guardare il webcast, in italiano, a bassa risoluzione, qui:

That's all folks!

Salve a tutti, sono Giuseppe Maggiore e sono qui impegnato per dare la stura ad un evento storico: il nostro primo video-tutorial ufficiale. Speriamo di avviare un trend di una certa lunghezza!

Bene, concluse le celebrazioni, diciamo un po' cosa fa questo tutorial: mostriamo un primo esempio basilare di come mandare geometria in wireframe sullo schermo, in 2D, come nell'immagine qui sotto:

per fare cio' ci servira' un VertexBuffer, ossia un puntatore a della memoria video appositamente creata per contenere i vertici che, a tre a tre, comporranno il nostro oggetto. Nell'esempio di sopra, il VertexBuffer contiene 6 vertici differenti, e il suo contenuto e' rappresentato qui sotto:

Purtroppo pero' stiamo facendo qualcosa di non raccomandabile: stiamo memorizzando i vertici della diagonale ben due volte, sprecando la nostra preziosa memoria video! Possiamo allora evitare di memorizzare le ripetizioni, specificando un ulteriore oggetto, il cosiddetto IndexBuffer, che descrive quali triplette di vertici vanno prese per costruire i nostri triangoli:

Nella seconda parte del videotutorial creiamo anche una classe, BasicMesh, per semplificarci la vita nel trattare oggetti (appunto, le Mesh) composti da un Vertex e da un IndexBuffer.

I link al file video sono a maggiore risoluzione, ma qui trovate un embedding low-res del videotutorial:

English version

Ciao!

Il mio nome è Alessandro Piva e sono un membro del team VS85. Come i miei compagni hanno già detto nei due post precedenti siamo persone molto interessate nella tecnologia e nella programmazione dei videogiochi; intendiamo utilizzare questo sito per pubblicare demo, webcast e tutorial per aiutare le persone (e anche noi stessi ) ad imparare la fantastica piattaforma XNA.

Oggi, spiegherò il terzo demo che abbiamo presentato alla conferenza all'Università Bicocca, a Milano, il 28 Novembre. Questo demo è chiamato "SoftCity" e mira a risolvere due sfide tecnologiche:

• Una tecnica di rendering avanzata chiamata deferred shading (a volta chiamata deferred rendering)
• La gestione dei contenuti (texture, modelli, l'intera città) attraverso l' XNA Content Pipeline.

Iniziamo dal deferred shader. Cos'è? E' una tecnica di rendering (cioè una procedura per disegnare cose su schermo), attualmente usata in molti videogiochi commerciali, che consente a grandi quantità di luci di essere presenti su schermo contemporaneamente. La nostra demo mostra quasi un centinaio di luci, e c'è spazio (e potenza computazionale) per averne di più.

La tecnica è abbastanza complessa da implementare, ma semplice da capire: anzitutto, si disegna il colore degli oggetti (l'albedo); dopo, si marca nello stencil buffer quei pixel che sono toccati da almeno una luce; infine, si calcolano le pesanti equazioni della luce, ma solo per i pixel interessati. In questo modo è possibile illuminare solo i pixel giusti, e non uno di più.

Ecco una paio di screenshot della nostra città:

E adesso parliamo della gestione dei contenuti. Nonostante questo possa sembrare più triviale di complesse tecniche di rendering, è stato un problema non da poco. Questo perché importare contenuti nel proprio programma (demo, gioco, o altro) crea molte difficoltà come la conversione tra file di diverso formato, la corrispondenza tra i dati forniti dal programma di creazione dei contenuti (nel nostro caso un programma di modellazione 3D) e le informazioni di cui si ha effettivamente bisogno nel proprio codice, eccetera. Nel risolvere questi problemi, abbiamo fatto un uso estensivo della Content Pipeline integrata nell'XNA Framework.

Abbiamo utilizzato il gratuito Softimage Mod Tool per costruire la nostra città. Grazie all'Add-On XNA Game Studio, abbiamo potuto importare i contenuti nel nostro demo; abbiamo scritto un nostro processore di contenuti per adattare i dati importati alle necessità del nostro renderer.

Ecco una coppia di screenshot della città mentre vi stavamo lavorando in Softimage:

 

Potete scaricare il codice sorgente o l'eseguibile (nonostante abbia bisogno ancora di molti rifinimenti). Buon divertimento!

English version

Salve gente! Sono Giuseppe Maggiore, membro di un gruppo di sviluppatori XNA noto (piu' o meno ;) ) come VS85Team (gli altri due sono Giulia Costantini e Alessandro Piva). In questo blog vi mostreremo, con una serie di tutorials, come scrivere videogiochi in XNA. Non servono conoscenze di sorta, tranne, un goccio di programmazione e d algebra (tranquilli, ci limiteremo al minimo indispensabile :) ).

Il mio personale lavoro sara' di mostrarvi una battaglia spaziale tra astronavi "buone" e "malefiche". Qui c'e' qualche immagine delle features che arriveremo ad imparare a realizzare.

Cominciamo dall'effetto warp con il cosiddetto "bloom", che fa apparire un alone di luce intorno agli oggetti che entrano nella scena. Questo effetto

usa i render target, nonche' molti pixel e vertex shader,

e l'impiego di una potente tecnica di postprocessing

chiamata "sfumatura gaussiana". Per ottimizzare il tutto dovremo anche impiegare lo stencil buffer, imparando a rendere piu' efficiente un pixel shader pesante ma che lavora su una sola porzione dello schermo!

A questo punto, implementeremo la battaglia vera e propria: le navi si aggireranno a vicenda, sparandosi missili che esploderanno sull'obiettivo frantumandosi in mille pezzi. Scudi di energia proteggeranno le navi dai

danni degli avversari, ma alla fine le astronavi troppo

danneggiate esploderanno in un effetto particellare piuttosto dinamico basato sull'alpha blending.

A breve cominceremo coi tutorials, ma al momento trovate online anche il sorgente. E' molto disordinato, ma se foste curiosi buttate pura una occhiata :) !

[English version] 

Ciao a tutti, io sono Giulia Costantini, un membro del VS85Team, e il mio compito sara' di mostrarvi una rete neurale in azione. Questa e' una cosa piuttosto particolare perche' delle reti neurali si parla (anche molto) ma vederle e' tutt'altro paio di maniche! Questa demo costituisce dunque un importante risultato, dal momento in cui le reti neurali sono difficili da visualizzare e anche da debuggare (se avete provato almeno una volta a programmarle capirete cosa intendo :) ). Con questa demo (centrata sul problema dello XOR, ma facilmente estendibile ad altri problemi) finalmente potrete VEDERE una rete neurale in azione!!.

Cominciamo dicendo che una Artificial Neural Network (ANN, da cui viene il nome della demo: AnnX :) ) puo' essere considerata uno "strumento magico" che riproduce il funzionamento del cervello umano. Per potersi comportare come un cervello, pero', la rete deve essere allenata. Non intendo annoiarvi con le "interiora" matematiche di una rete neurale; vi mostero' la demo AnnX e, un po' alla volta, vi insegnero' a costruirla da zero.

La nostra rete, che e' abbastanza piccola, risolve il problema dello XOR, quindi l'input della rete consiste di 2 bits (ad esempio 0 e 1) e l'output consiste di un valore (lo XOR dei due bit di input). All'avvio del programma dovete premere il tasto "E" per allenare la rete: in questo modo la rete impara a risolvere il problema dello XOR. Quando l'allenamento e' finito (non vi preoccupate, dura solo pochi secondi!) il programma mostra un messaggio:

Dopodiche', potete premere "spazio" e... ha inizio la magia!!! Piccole palline rotanti (rappresentanti il potenziale dei nodi) cominciano a fluire attraverso la rete, portandovi alla fine al risultato corretto del problema considerato. Ad esempio, il risultato dello XOR tra 0 e 1 e'...

...0.98!!! Il risultato preciso dovrebbe essere 1, ma direi che possiamo accettare questo tipo di approssimazione e considerare il risultato corretto :) !

Vorrei richiamare la vostra attenzione su due cose:

• sulle sfere che rappresentano i nodi e' presente un effetto grafico, chiamato environment mapping. Grazie a questo effetto l'ambiente circostante viene riflesso sull'oggetto considerato (nel nostro caso le sfere). Per implementare questo effetto dovremo scrivere un vertex e pixel shader, ma, non essendo l'effetto troppo complicato, sara' abbastanza facile. Qui potete scaricare un PDF in cui si spiega il cube mapping, cioe' l'implementazione dell'environment mapping che abbiamo usato.
• per scegliere dove effettivamente mettere i singoli nodi sullo schermo (avreste mai immaginato che questo potesse essere un problema? :) ) dobbiamo usare un tool per disegnare grafi. Infatti una rete neurale e' molto simile ad un grafo (nodi + archi). Grazie a tale tool, possiamo cambiare la struttura della rete a piacimento senza doverci preoccupare del layout dei nodi. Abbiamo scelto la libreria Microsoft GLEE, che e' gratuita e funziona meglio di tutti gli altri tool che abbiamo provato.  

Per concludere, perche' questa demo e' importante? Perche' abbiamo mostrato che, con l'aiuto di alcune potenti tecnologie(XNA, GLEE e non dimentichiamoci il C#!), le reti neurali non sono piu' uno strumento matematico mistico e incomprensibile: le reti neurali possono essere davvero divertenti, sia da programmare che da usare!!! Nell'arco dei prossimi mesi posteremo dei webcast in cui spiegheremo nei dettagli come realizzare questa demo, ma, se proprio non potere resistere :), sappiate che il codice sorgente della demo e' online (come anche l'eseguibile), quindi, se volete guardarlo o provare a modificare, voi (e le vostre domande ;) ) siete i benvenuti!!!

Giulia Costantini