Links de descargas actualizados

Por si a alguien no les funcionaban los revise y actualicé. Perdón por las molestias !

XNA tutorial 3 – colisiones :serie 1:

En este artículo voy a comentar como estoy manejando la detección de colisiones con los limites del área dibujada.

Antes de empezar, hay que aclarar el concepto de “bounding frustum”. Básicamente y en cristiano es el área o volumen que estamos dibujando. Esta limitado por planos donde los mas importantes son el front y el back (que por ahora no vamos a usar). Para ver mejor el concepto pueden visitar esta dirección.

Este es el gráfico (el cual es bastante auto explicativo):

La única diferencia es que nosotros tenemos girado todo 90º:

Otro concepto que debemos conocer es el de Collision Sphere: esto es una esfera con el volumen suficiente para contener un modelo en tres dimensiones.  Lo bueno de utilizar este tipo de objetos para la detección de colisiones es que cuando rotamos o movemos el modelo, actualizar  la esfera es muy fácil (ya que no varía, es solo un punto y un radio). Un punto muy negativo es que para cálculos complejos no es precisa, pero para este ejemplo sobra.

El algoritmo para crearla se sitúa en el método load (necesitamos la información del modelo)

foreach (ModelMesh mesh in model.Meshes)
    collisionSphere = BoundingSphere.CreateMerged(collisionSphere, mesh.BoundingSphere);

Algoritmo

Como dije antes, el bounding frustum es un área delimitada por planos. Lo que vamos a hacer, utilizando métodos de las clases, es ver si existe una intersección entre la esfera (bounding sphere) que contiene a la nave y los limites del frutum. Esta prueba debemos hacerla en la próxima posición, por lo que creamos un vector y una esfera de prueba.

// control de posicion para la coordenada x
Vector3 collisionTestVector = Vector3.Zero;
BoundingSphere collisionTestSphere;

collisionTestVector.X = position.X + movement.X;
collisionTestVector.Z = position.Z;
collisionTestVector.Y = movement.Y;

collisionTestSphere = new BoundingSphere(collisionTestVector, collisionSphere.Radius);

if (Camera.BoundingFrustum.Contains(collisionTestSphere) == ContainmentType.Intersects)
    movement.X = 0;

Ese código muestra como fue realizado para la coordenada X. En el ejemplo esta también implementado para Z.

Desde este link pueden descargar la solución.

Slides CodeCamp 2009 – Desarrollo de juegos con XNA

Para el que las quiera, acá dejo las diapositivas de mi charla en la CodeCamp 2009:

LINK DE DESCARGA

Disfruten !

XNA tutorial 2 – clase AirCraft

En el artículo anterior use un modelo para mostrar que la cámara funcionaba como era esperado, pero la forma de dibujarlo era desprolija y estaba dentro de la clase Game1. Hoy voy a separar esa información para tenerla ordenada y de paso discutir un poco la clase AirCraft que vendría siendo el avión que vamos a controlar.

Entre los atributos principales tenemos el modelo, la textura y la posición. Los demás atributos son secundarios (pero aún útiles) y están explicados en el código.

Estoy haciendo un esfuerzo y voy a dejar algunos comentarios en español (aunque parezca mentira me cuesta recordar esto), pero si algún lector tiene una duda puede preguntar vía comentario.

public class AirCraft
{
    private Model model;
    private Texture2D texture;
    private Vector3 position;

    private string modelAsset = "untitled";
    private string textureAsset = "Ship_06";

    private float speed = 20;

    public AirCraft(Vector3 position)
    {
        this.position = position;
    }

    public void Load(ContentManager content)
    {
        model = content.Load<Model>(modelAsset);
        texture = content.Load<Texture2D>(textureAsset);
    }

    public void Update(GameTime gameTime)
    {
        Vector3 movement = Vector3.Zero;

        // cuanto tiempo paso desde el ultimo frame hasta el actual
        float deltaT = (float)gameTime.ElapsedGameTime.TotalSeconds;
        /*
         * DeltaT sirve para calcular la cantidad de unidades que nos movemos en este frame.
         * Si decidimos que la velocidad de la entidad (nave) es de 1 metro por segundo,
         * hay que realizar una regla de tres
         * ya que en un segundo pueden entrar varios (muchos generalmente) frames.
         * */

        // actualizamos el vector movement que indica cuanto nos movemos en este frame particular
        if (Keyboard.GetState().IsKeyDown(Keys.Left))
            movement.X -= deltaT * speed;
        else if (Keyboard.GetState().IsKeyDown(Keys.Right))
            movement.X += deltaT * speed;

        // actualizamos la posicion
        position += movement;
    }

    public void Draw()
    {
        /*
         * Para dibujar el modelo copiamos sus transformaciones a una matriz.
         * Esto sirve para luego aplicar calculos matematicos a cada set de
         * transformaciones de cada mesh.
         * */

        Matrix[] contenedor = new Matrix[model.Bones.Count];
        model.CopyAbsoluteBoneTransformsTo(contenedor);

        foreach (ModelMesh mesh in model.Meshes)
        {
            foreach (BasicEffect effect in mesh.Effects)
            {
                effect.World = contenedor[mesh.ParentBone.Index]
                    * Matrix.CreateTranslation(position);
                effect.View = Camera.View;
                effect.Projection = Camera.Projection;
                effect.TextureEnabled = true;
                effect.Texture = texture;
            }
            mesh.Draw();
        }
    }
}

La clase es bastante auto explicativa, pero si tienen dudas dejen el comentario.

Acá dejo la solución para que la descarguen.

XNA – tutorial 1 – upside down camera

Introducción

La idea es hacer un juego de aviones tipo raptor (si, aquel que jugabamos en D.O.S.) pero realizado en 3D.

A diferencia de mis otros tutoriales, estos van a ser mucho mas complejos y apuntan a programadores con conocimientos avanzados de orientación a objetos y análisis matemático. Esta vez tengo novia, trabajo y vivo solo por lo tanto el tiempo escasea y no da para detenerme en tantas explicaciones. Lo siento…

Camara “Upside Down”

Como dije, la idea es un juego en 3d que se ve de arriba. A diferencia de los juegos en dos dimensiones, para dibujar modelos y objetos con volumen necesitamos una cámara virtual. La idea es mas o menos esta:

public static class Camera
{
    public static Matrix World { get; private set; }
    public static Matrix View { get; private set; }
    public static Matrix Projection { get; private set; }

    public static Vector3 Position { get; set; }

    // needed attributes
    private static float nearClip = 1.0f;
    private static float farClip = 1000.0f;
    private static float fov = MathHelper.PiOver4;

    private static float ratio = 800 / 600; // default aspect ratio
    public static float Ratio
    {
        get { return ratio; }
        set { ratio = value; }
    }

    // helper utils
    private static Matrix rotationMatrix = Matrix.CreateRotationX(MathHelper.ToRadians(90));

    public static void Update()
    {
        UpdateMatrices();
    }

    private static void UpdateMatrices()
    {
        Vector3 transformedReference = Vector3.Transform(Vector3.Forward, rotationMatrix);

        View = Matrix.CreateLookAt(Position + transformedReference, Vector3.Zero, Vector3.Up);
        Projection = Matrix.CreatePerspectiveFieldOfView(fov, ratio, nearClip, farClip);
        World = Matrix.Identity;
    }
}

El método UpdateMatrices es el mas importante. No tiene nada que no se haya visto anteriormente. Se genera una transformación en un vector y se gira 90 grados para poder ver el modelo desde arriba.

Nota: en el ejemplo deje algo de lógica para que vean la cámara en acción.

Ahora dejo como descarga el proyecto de prueba.

descargar ejemplo

---

Zune MP

No entiendo cuando la gente dice que iTunes es “bonito”. De verdad es pesado, a mi gusto totalmente antiestético. Además que las funciones… no funcionan !!!!

He pasado por varios media players. Uno de los que mas me gusto fue foobar, pero me canse de lo tediosa que era la actualización del player y los plugins.

Winamp nunca me gustó: al principio no tenía biblioteca y cuando la agregaron fue horrible.

Ahora estoy usando (y al parecer seguiré) el Zune media player, aunque no tengo un Zune…. El reproductor es muy simple y visualmente es una locura. La funcionalidad para obtener información del disco es asombrosa. Hay algunas cosas que todavía no se hacer, como el ordenamiento por álbum o esas cosas. Ya iré aprendiendo.

Recomiendo probarlo porque es bastante superior a los otros. Eso si, no puedo sincronizar mi IPhone (pero era algo que esperaba).

Increíble el CodeCamp 2009

Aprovecho para agradecer a toda la gente que asistió al evento. Impresionante realmente. Es una gran oportunidad para los que vivimos en el interior poder ir y exponer lo que hemos aprendido en el año.

No puedo dejar la entrada sin agradecer a la gente responsable de la organización. Seguro me faltan miles porque no los conozco a todos, pero bueno, se hace lo que se puede.

Viviana Basile, Miguel Angel Saez, Mara Lopez: Se pasaron, no falló nada (al menos visible) y fue muy grato todo. Se las/los vio corriendo por todos lados, pero dio frutos !

También quiero agradecer a toda la gente de Microsoft y Microsoft Programa Académico por brindar la tecnología y la buena onda.

Apenas revele las fotos agrego !

Links:

http://www.codecamp.com.ar/

Fotos