motorXna

En este tutorial vamos a ver un concepto nuevo y aveces dificil para algunos: la animacion esqueletal.
Quiero aclarar que no voy a cubrir un tutorial de como hacer un modelo y como aplicarle un esqueleto, hay mucho material dando vuelta al respecto. Por mi parte estoy usando Milkshape 3d.

Como dije antes un modelo es un conjunto de meshes que forman un objeto, en los ejemplos que venimos siguiendo, nuestro modelo es un auto, contiene 5 meshes, estos son las 4 ruedas y el chasis.
Imaginen que queremos hacer una animacion, por ejemplo hacer rotar una rueda. Lo logico seria tomar todos los vertices de la rueda y aplicarles una transformacion (en este caso, rotacion).
Pero calcular todo esto implica calculos matematicos, y cuando se tiene un modelo complejo, con unos cientos de miles de vertices, la practica se hace imposible de aplicar.

Para solucionar este problema se usa un concepto llamado "animacion esqueletal" donde se aplica un esqueleto al modelo.
Un esqueleto no es mas que una cadena de uniones y huesos emparentados.



Algunas cosas importantes:

• Los esqueltos tienen forma hereditaria, un padre tiene uno o mas hijos.
• Un hueso conoce solo su hermano mas cercano y no tiene informacion de los demas.
• Los esqueletos tienen un nodo raiz
• El movimiento de un hijo afecta los anteriores

Ahora, cada union, puede tener asignado un grupo de vertices que obedeceran a esta, osea, que si aplico una transformacion a una union con vertices asociados, estos se deformaran igual que la union:


En la imagen, se ve que una union tiene los vertices de la rueda, osea que si deformo la union (ejemplo rotarla) se deforman los vertices. Facil .

Primero, aca estan los archivos que vamos a necesitar:

3Contenido.rar

Ahora, al codigo:

Lo primero que vamos a hacer, es deshacernos del contenido viejo.



Ahora agregamos el contenido nuevo (autito.x y autotext.png). Esto lo hacemos igual que como lo veniamos haciendo antes.

Ahora vamos a modificar los valores de la camara (las dimensiones del autito cambiaron), en MiGame modificamos la camara para que quede asi:

camara = new Vector3(0.0f, 30.0f, 60.0f);

Ahora vamos a MisObjetos.
Vamos a re escribir todas las variables, ya que muchas no las vamos a usar mas, entonces, todo el codigo hasta el constructor tiene que quedar asi:

 //variables
        protected Model modelo;

        //movimiento
        protected float rotacionDelantera = 0.0f;
        protected float rotacionTrasera = 0.0f;
        protected float rotacion = 0.0f;

        //bones
        ModelBone boneRueda1;
        ModelBone boneRueda2;
        ModelBone boneRueda3;
        ModelBone boneRueda4;
        
        //transformaciones iniciales
        Matrix transRueda1;
        Matrix transRueda2;
        Matrix transRueda3;
        Matrix transRueda4;

        //contenedor
        Matrix[] boneTransf;

Mucho ? Les explico. Las variables de rotacion son para rotar el eje delantero, trasero y el chasis completo del auto. No hay mucha ciencia en esas variables.
Las variables ModelBone sirven para hacer referencia a distintos bones del modelo, estos ya traen la informacion de los vertices que tienen asociados.
Las matrices transRuedaX almacenan la transformacion inicial de cada bone.
Por ultimo, vamos a hacer una matriz que va a contener todas las nuevas transformaciones del esuqeleto.

Vamos ahora, al codigo del metodo "Load", que deberia quedar como sigue:

        public void load(ContentManager content)
        {
            modelo = content.Load<Model>("Recursos/autito");

            //inicio los bones que voy a mover
            boneRueda1 = modelo.Bones["bone_rueda1"];
            boneRueda2 = modelo.Bones["bone_rueda2"];
            boneRueda3 = modelo.Bones["bone_rueda3"];
            boneRueda4 = modelo.Bones["bone_rueda4"];            
            
            //guardo las transformaciones iniciales
            transRueda1 = boneRueda1.Transform;
            transRueda2 = boneRueda2.Transform;
            transRueda3 = boneRueda3.Transform;
            transRueda4 = boneRueda4.Transform;

            //inicializo la matrz que va a guardar todos los cambios
            boneTransf = new Matrix[modelo.Bones.Count];

        }

El codigo no es dificil, solo instanciamos los bones que queremos mover o transformar y guardamos la transformacion inicial.

Ahora vamos a re escribir el metodo update deacurdo a las nuevas variables:

        public void update()
        {
            KeyboardState estado = Keyboard.GetState();

            if (estado.IsKeyDown(Keys.Up))
            {
                rotacionDelantera = rotacionDelantera + 0.1f;
            }
            if (estado.IsKeyDown(Keys.Down ))
            {
                rotacionDelantera = rotacionDelantera - 0.1f;
            }

            if (estado.IsKeyDown(Keys.Left))
            {
                rotacion += 0.1f;
            }
            if (estado.IsKeyDown(Keys.Right))
            {
                rotacion -= 0.1f;
            }
        }

Por ultimo, el metodo dibujar quedaria como sigue:

        public void dibujar(Matrix world, Matrix vista, Matrix proyeccion)
        {
            modelo.Root.Transform = world * Matrix.CreateRotationY(rotacion);

            Matrix rotacionBonesDelanteros = Matrix.CreateRotationX(rotacionDelantera);
            Matrix rotacionBonesTraseros = Matrix.CreateRotationX(rotacionDelantera * 0.33f);

            boneRueda1.Transform = transRueda1 * rotacionBonesDelanteros;
            boneRueda2.Transform = transRueda2 * rotacionBonesDelanteros;

            boneRueda3.Transform = transRueda3 * rotacionBonesTraseros;
            boneRueda4.Transform = transRueda4 * rotacionBonesTraseros;
            
            modelo.CopyAbsoluteBoneTransformsTo(boneTransf);

            foreach (ModelMesh mesh in modelo.Meshes)
            {
                foreach (BasicEffect efecto in mesh.Effects)
                {
                    efecto.EnableDefaultLighting();
                    efecto.World = boneTransf[mesh.ParentBone.Index];
                    efecto.View = vista;
                    efecto.Projection = proyeccion;
                }
                mesh.Draw();
            }
        }

Tampoco hay mucha ciencia, es solo analizar. Lo que hice fue crear una rotacion en el eje X para cada eje (el eje tracero es solo 1/3 de rapido que el delantero, para que vean la independencia de los bones), luego le aplique la transformacion a cada bone y copie las transformaciones finales a la matriz contenedora.

IMPORTANTE:
si el proyecto no les compila, es porque tiene cacheada info vieja, eliminen el contenido de:
MiMotor\obj\x86\Debug\Recursos

Fuentes:
MiPrimerJuego-tutorial-6.rar

DISCUTI ESTE ARTICULO ACA

Lo prometido es deuda, aca vamos a ver algunos conceptos interesantes. Antes de empezar con la practica les recuerdo que C# es orientado a objetos por lo tanto vamos a explotar dicha cualidad al maximo.

Como dije en otro post, pensaba dedicar este ejemplo a renderizar un sprite, pero por ahora no nos interesa en nuestro motor 3d, por lo tanto este tutorial se va a referir a incluir un modelo al programa.
Muchos de los tutoriales que encontre no tratan este tema bien, en lo que respecta a la orientacion a objetos, pero en este espacio todos tratamos de ser buenos programadores, asi que vamos a hacer las cosas como se debe.

Una consideracion antes de empezar, no pretendo que nadie sepa como modelar en 3 dimensiones, obviamente es un proceso mas complicado que hacer un sprite, donde valiendonos con solo el paint lo podemos hacer.
Los modelos que vamos a usar son hechos por mi (no importa con que software), ya van a estar listos para importar en el formato correcto.

Antes de cargar nuestro modelo, quiero estar seguro que todos sepan lo que es, para ello voy a hacer una comparativa contra una textura.

• En una textura o sprite, la unidad minima es el pixel, en un modelo es el vertice.
• Una linea entre 2 pixeles forma... una linea , una linea entre 2 vertices no forma nada.
• Un conjunto de al menos 3 vertices unidos, forma una cara. Por lo tanto, el objeto mas basico que se puede observar es un triangulo.
• Un conjunto de caras forma un poligono.
• Un conjunto de poligonos forma un "mesh".
• Un conjunto de meshes forma un modelo.

No es dificil, no ? Bueno, faltan algunas cosas como materiales y esqueletos, pero lo vamos a dejar para otro tutorial.

BIEN ! ya sabemos lo que es un modelo, pero como lo metemos al programa ???? facil, con matrices, mas precisamente, una matriz de transformaciones.
Dicha matriz es muy importante, contiene 3 cosas importantisimas en el mundo de la programacion en tres dimensiones:

1. Posicion
2. Escala
3. Orientacion

Lo que vamos a hacer es plamar la informacion del modelo en una matriz para representarlo.

Para poder verlo, necesitamos una "vista", que tambien se representa con una matriz. No necesitamos un modelo para la vista, es solo un concepto.

Bueno, ya tenemos cocinada toda la teoria, vamos a las piñas.

Primero, bajen en modelo que vamos a usar:
pilon.X

Ahora vamos a definir una variable que va a ser nuestra "camara" virtual, en la inicializacion de variables agregamos la linea:

Vector3 camara;

En nuestro ejemplo, quedaria:

    ...
    public class MiGame : Game 
    {
         //variables
        GraphicsDeviceManager miDispositivoGrafico;
        ContentManager miContenido;
        Vector3 camara;
    ...

En el constructor de nuestro ejemplo, iniciamos la camara como sigue:

camara = new Vector3(0.0f, 5.0f, 5.0f);

En nuestro ejemplo quedaria:

        //constructor
        public MiGame()
        {
            miDispositivoGrafico = new GraphicsDeviceManager(this);
            miContenido = new ContentManager(Services);
            camara = new Vector3(0.0f, 5.0f, 5.0f);
        }

Todavia estoy experimentando con esto, pero quiero aclarar que en el mundo de XNA, el eje Z no es arriba ya bajo. En XNA el eje Y es con el que se indica la altura.

Ahora vamos a iniciar las matrices necesarias para dibujar en 3d. Los conceptos que tengo sobre estas matrices todavia son MUY basicos y puede que en algunos este equivocado. Si alguien quiere corregirme, como siempre, es bienvenido.

EL metodo draw nos quedaria:

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

            float aspectRatio = 640.0f / 480.0f;

            Matrix world = Matrix.Identity;

            Matrix view = Matrix.CreateLookAt(camara, Vector3.Zero, Vector3.Up);

            Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f);           

            base.Draw(gameTime);
        }

Ufff... cuantos conceptos nuevos, vamos de apoco.

La matriz de Proyeccion muestra los objetos tridimiensionales de forma que los entendamos en nustro simple dispositivo de 2 dimensiones (lease monitor).
Mas info (en ingles) LINK.

La matriz World contiene los objetos que vamos a utilizar, su rotacion, escala etc. En este momento no tenemos nada inicializado, asi que la inicializamos como el objeto neutro en las matematicas, en el espacio de matrices, la identidad.
La matriz view ya la charlamos, contiene la camara y el destino.
Cualquier modificacion de los objetos(3d), deberia quedar plasmada en esta matriz (por ejemplo una rotacion.
En este punto deberian poder compilar el proyecto sin problemas.

Vamos a agregar el modelo a nuestro proyecto, primero para ordenar las cosas creamos una carpeta para nuestros recursos.
Click derecho en MiMotor -> add -> "Nueva carpeta". Como nombre, le ponemos "Recursos".



Ahora hacemos click derecho en "Recursos" -> add -> elemento existente y buscamos el modelo (pilon.X). Recuerden que en tipo de archivo tienen que elegir "Content pipeline".



Ahora vamos a crear un nombre de espacios que va a contener los objetos basicos de nuestro motor.
Hacemos click derecho en "MiMotor" -> add -> Nuevo elemento. Seleccionamos Game Component y como nombre ponganle "MisObjetos". Borren todo el contenido antes de seguir.
En este componente vamos a crear una clase simple para crear un objeto muy basico, solo tendra una propiedad, un modelo.

Agregamos los nombres de espacios necesarios:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input;

using System;

Creamos nuestro nombre de espacios y agregamos una clase:

namespace MisObjetos
{
    public class MiObjetoGenerico
    {
    }
}

Agregamos sus propiedades y constructor:

        //variables
        protected Model modelo;       

        public MiObjetoGenerico()
        {            
        }

Ahora vamos a ver otro concepto importante. Cada objeto tendra sus propios metodos update, draw y load.
El metodo Load va a ser el encargado de cargar el modelo. Recordemos que no se puede cargar el modelo en el constructor, bueno se podria, pero podriamos estar ante un error de diseño.
Despues del constructor, agregamos:

        public void load(ContentManager content)
        {
            modelo = content.Load<Model>("Recursos//pilon");
        }

Como parametro recibe un manejador de contenido (que ya estara inicializado en la clase principal).

Nota: Es MUY importante el nombre (asset) del modelo, para verlo, en la ventana de propiedades (f4 si no la ven), aparece.

Lo unico que nos queda es el metodo Draw (dibujar), que es bastante simple, despues del metodo Load agregamos el siguietne codigo:

        public void dibujar(Matrix world, Matrix vista, Matrix proyeccion)
        {
            foreach (ModelMesh mesh in modelo.Meshes)
            {
                foreach (BasicEffect efecto in mesh.Effects)
                {
                    efecto.EnableDefaultLighting();
                    efecto.World = world;
                    efecto.View = vista;
                    efecto.Projection = proyeccion;
                }
                mesh.Draw();
            }
        }

Recordemos que los mesh componen un modelo, effect es la forma en la que se dibujan los meshes (creo).

Nuestro objeto basico esta listo ! Ya podemos compilar y no deberiamos tener problema. Ahora tenemos que agergar el objeto a nuestro motor.

Vamos a la declaracion de variables y agregamos el codigo necesario, quedaria:

        //variables
        GraphicsDeviceManager miDispositivoGrafico;
        ContentManager miContenido;
        Vector3 camara;
        MisObjetos.MiObjetoGenerico objeto;

En el constructor:

        //constructor
        public MiGame()
        {
            miDispositivoGrafico = new GraphicsDeviceManager(this);
            miContenido = new ContentManager(Services);
            camara = new Vector3(0.0f, 5.0f, 5.0f);
            objeto = new MisObjetos.MiObjetoGenerico();
        }

Recordemos que no podemos cargar modelos y texturas hasta que los recursos esten listos, por lo tanto, en el metodo LoadGraphicsContent, el cual agregaremos despues del metodo Update, quedaria como sigue:

        protected override void LoadGraphicsContent(bool loadAllContent)
        {
            if (loadAllContent)
            {
                //cargar...    
                objeto.load( miContenido );
            }
            base.LoadGraphicsContent(loadAllContent);
        }

Lo unico que queda es dibujar nuestro objeto. Nuestro metodo Draw quedaria:

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

            float aspectRatio = 640.0f / 480.0f;

            Matrix world = Matrix.Identity;

            Matrix view = Matrix.CreateLookAt(camara, Vector3.Zero, Vector3.Up );

            Matrix projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f), aspectRatio, 1.0f, 10000.0f);

            objeto.dibujar(world,view,projection );

            base.Draw(gameTime);
        }

Si todo salio bien, van a poder ver un lindo modelo dibujado en la pantalla.

Fuentes:
MiPrimerJuego-tutorial-3.rar

DISCUTI ESTE ARTICULO ACA

Ya tengo todo el material para el siguiente tutorial. Al principio pensaba mostrarles como cargar un sprite (osea, una texturita en 2d), pero lo cambie para mostrarles como cargar un modelo en 3D y como rotarlo ( mucho mas interesante que un sprite si me preguntan ). Mañana voy a ver si publico el tutorial 3.
Con respecto al titulo de esta entrada del blog, es lo que viene despues de cargar un modelo al motor... la animacion.

XNA no tiene metodos nativos para manejar animaciones, y para desarrollar una clase hay que saber muchas cosas del lenguaje, como por ejemplo armar un importador desde cero (ayudandonos con la herencia claro).
Aun heredando el comportamiento del importador (de ahora en mas processor), es bastante dificil de programar. Hay que saber muchisimo de modelos en 3 dimensiones, esto implica bones, vertices y demas yerbas relativas.

Como si fuera poco hay que tener MUY claro el concepto de matrices de transformaciones, como usar las transformaciones y como acceder a cada parte del modelo... Todos estos conceptos (no todos pero si un 80%) son nuevos para mi, y tengo que leer mucho antes de ponerme a coddear. Nuevamente invito a quien quiera compartir sus conocimientos a hacerlo.
Microsoft prometio un tutorial al respecto, pero aun no hay noticias, bueno si, hay una noticia. Al parecer uno de los bloggers de msdn tiene algo preparado, pero es tan complejo que todavia le esta haciendo reviews. Aparte necesita ( segun el ) algunas firmas y aprobaciones legales. -> Link.

Como dije antes, es muy probable que el tutorial 3 (como importar un modelo) este listo para mañana, pero no queda duda que el tutorial 4 va a tener una demora considerable.
Igual no desesperen, voy a dedicar algunas entradas del blog para instruirlos sobre los siguientes temas:

• Que es un mesh (vertices, lineas, caras, poligonos)
• Que es un modelo
• Que es un content processor - como desarrollar uno - codigo de un processor
• Usar el content processor para cargar nuestro modelo en vez del usado por defecto
• Que es la matriz de transformaciones
• Animacion vectorial
• Animacion Esqueletal

Yo se que es pesado y a muchos no les interesa, pero si quieren hacer juegos tienen que tener una cultura muy amplia del tema. No es cuestion de llamar una funcion y listo. Hay que entenderla, procesarla, poder reproducirla y lo mas importante de todo, modificarla para agregarle un comportamiento. Quiero que los que lean este blog no aprendan el framework, sino tamiben que se vuelvan mejores programadores (me incluyo tambien).

Bienevidos al Tutorial 1.
Antes que nada, quiero aclarar que junto con los lectores, yo mismo voy aprendiendo de esta tecnologia, por lo tanto, es muy probable que haya que hacer correcciones ( los tips y correcciones de los lectores seran bienvenidos ).
En este Tutorial, les voy a enseñar como armar el entorno desde cero. Con esto no me refiero a hacer click en nuevo proyecto, sino a explicar un poco las funciones y armar los archivos desde el comienzo.
Para seguir estos tutoriales, se requieren conocimientos de programacion en general, si conocen Java quizas no se pierdan tanto, ya que C# es bastante parecido.
Generalmente intento programar siguiendo el paradigma de orientacion a objetos, asi que eso tambien va a ser necesario. No tengo drama en ayudar mediante los comentarios.

Lo primero que hay que hacer, es abrir el Visual C# Express Edition, y comenzar un nuevo proyecto.
Vamos a seleccionar Windows Game Library. Como ejemplo yo le puse "MiMotor" a la Library y "MiPrimerJuego" a la solucion.
Recuerden que Las soluciones pueden tener multiples proyectos, recursos, etc.



A la izquierda debería estar el explorador de soluciones, van a ver que hay un archivo que se llama Class1.cs. Hagan click derecho y seleccionen Eliminar.



Ahora vamos a agregar un proyecto que va a servir para ir viendo el progreso del motor.
Hacemos click derecho en el nombre de la solucion ("MiPrimerJuego") y seleccionan "Add" (agregar) "Nuevo Proyecto".
En la casilla nombre pongan "MotorDemo", y borren los archivos por defecto, estos archivos son: Game1.cs y Program.cs.

NOTA: La idea de armar el proyecto en una libreria Y en un ejecutable, comenzo por querer tener las cosas ordenadas. De esta forma, quedaria un ejecutable, una libreria con las funciones y los recursos (que pueden estar o no incluidos en la libreria, todavia no se bien como voy a hacerlo).
Un ejemplo (creo) de este desarrollo, es el quake 2, que se guia mas o menos por este metodo (repito, CREO).

Antes de empezar con la programacion, hagan click derecho en el proyecto "MotorDemo" y seleccionen la opcion "Establecer como proyecto de inicio". Nuevamente hagan click derecho en "MotorDemo" y seleccionen "Agregar Referencia".
En el popup que aparecio, seleccionen la pestaña "Proyectos" y hagan doble click en "MiMotor".

Ahora a codear un poco.
En "MiMotor" hagan click derecho y seleccionen "Add->Clase".

El nombre de la clase va a ser "MiGame". Esta clase va a heredar propiedades de la clase Game.
Borren todo el contenido del archivo MiGame.cs, vamos a escribirlo desde cero para que aprendan que es cada cosa.
El primer codigo que vamos a incluir son las llamadas a las librerias necesarias:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input;

NOTA: Los namespaces contienen clases que vamos a necesitar, por ejemplo Graphics contiene clases para acceder a la palca de video.
En este tutorial voy a crear algunos Namespaces, por ejemplo, mas adelante, para crear un objeto en el juego, vamos a hacerlo como MiNamespace.Objetos.ObjetoGenerico miObjecto.
Es bastante ordenado.
Recuerden que si no hacemos namespaces c# lo hara por nosotros, pero es mejor tener las cosas bien ordenadas.
Mas informacion: link

Ahora vamos a crear un namespace y poner nuestra clase principal:

namespace MiMotor
{
    public class MiGame : Game 
    {
    }
}

Como todos sabemos, las clases tienen variables (propiedades), operaciones (metodos) y constructores (tambien destructores).
Vamos a declarar algunos para nuestra clase, dentro de la misma, agregamos el siguiente codigo:

 
        //variables
        GraphicsDeviceManager miDispositivoGrafico;
        ContentManager miContenido;

        //constructor
        public MiGame() 
        {
            miDispositivoGrafico = new GraphicsDeviceManager(this);
            miContenido = new ContentManager(Services);            
        }

GraphicsDeviceManager se encarga de manejar la configuracion de nuestro dispositivo grafico.
ContentManager, se encarga de cargar objetos desde archivos binarios para usarlos mas tardes (por ejemplo una textura). Esto lo vamos a usar mas adelante.
Ahora vamos a llamar a la funcion que dibuja la ventana.

        protected override void Draw(GameTime gameTime)
        {
            miDispositivoGrafico.GraphicsDevice.Clear(Color.DarkOrange);  
            base.Draw(gameTime);
        }

El metodo Draw siempre se esta ejectuando, se encarga de renderizar o dibujar los objetos en la pantalla, no deberia haber codigo logico aqui (operaciones).

Bien, antes de seguir, el codigo de MiGame.cs deberia quedar asi:

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Input;

namespace MiMotor
{
    public class MiGame : Game 
    {
         //variables
        GraphicsDeviceManager miDispositivoGrafico;
        ContentManager miContenido;

        //constructor
        public MiGame()
        {
            miDispositivoGrafico = new GraphicsDeviceManager(this);
            miContenido = new ContentManager(Services);            
        }

        protected override void Draw(GameTime gameTime)
        {
            miDispositivoGrafico.GraphicsDevice.Clear(Color.DarkOrange);
            base.Draw(gameTime);
        }
    }
}

Ahora, agregamos una clase para el proyecto "MotorDemo", que se va a llamar "MiDemo". Como antes, borren todo el contenido.

Lo primero que vamos a escribir, es indicarle al programa que vamos a usar clases de nuestro namespace anterior.

using MiMotor;

Este proyecto solo va a instanciar a nuestro motor y lo va a hacer correr, para ello, escribimos el siguiente codigo:

namespace MiDemo
{
    class MiDemo
    {
        static MiGame game = new MiGame();

        public static void Main()
        {
            game.Run();
        }
    }
}

Este codigo es muy simple, es importante que main tenga la M (mayuscula).
Para terminar, el codigo deberia quedar como sigue:

using MiMotor;

namespace MiDemo
{
    class MiDemo
    {
        static MiGame game = new MiGame();

        public static void Main()
        {
            game.Run();
        }
    }
}

Si hicieron todo bien, al ejecutarlo deberian ver una linda pantalla naranja.
En el proximo tutorial vamos a ver algo de teclado y cambios de resulucion.

Fuentes:
MiPrimerJuego-tutorial-1.rar

DISCUTI ESTE ARTICULO EN EL FORO