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

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!