Windows Live Agents

 Muchos me han pedido que les explique como hacer un agente para el
messenger, en realidad este proceso puede ir desde lo sencillo hasta
algo muy complejo, obvio depende de que quieran hacer, por el momento
simplemente haremos uno que detecté cuando estas ausente y si recibes
un mensaje que le devuelva al remitente una respuesta.

Para esto vamos a crear un proyecto de biblioteca de clases.

Despúes agregamos como referencia el assembly MessengetClient.dll (que se encuentra dentro de la carpeta Windows Live/Messenger de archivos de programa.

Con esto vamos a poder utilizar en namespace Microsoft.Messenger el
cual es necesario para crear una interfase en nuestra clase llamada IMessengerAddIn.

Para implementar dicha interfase debemo agregar el método Initialize(), aquí vamos a crear una instancia del cliente del cliente del messenger


using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Messenger;

namespace WindowsLiveMessengerAgent
{
public class MessengerAddIn
: IMessengerAddIn
{
private MessengerClient _client;
private void IncomingTextMessage(object sender,
IncomingTextMessageEventArgs e)
{
if (_client.LocalUser.Status == UserStatus.Away)
_client.SendTextMessage(
"Lo siento, en este momento me encuentro ausente" +
"nDeja tu mensaje y me comunico más tardenn" +
_client.LocalUser.FriendlyName, e.UserFrom);

}
#region IMessengerAddIn Members

public void Initialize(MessengerClient messenger)
{
_client = messenger;

_client.AddInProperties.FriendlyName =
"WindowsLiveMessengerAgent";
_client.AddInProperties.Description =
"Este agente responde cuando no estas en linea.";

_client.IncomingTextMessage +=
new EventHandler<IncomingTextMessageEventArgs>
(this.IncomingTextMessage);
}

#endregion
}
}

Nota: antes de compilar hay que asegurarnos (de hecho no esta por
default) de que nuestro assembly se llame igual que nuestro bot + . +
nombre de la clase principal, ejemplo:

WindowsLiveMessengerAgent.MessengerAddIn

Una vez compilada nuestra biblioteca debemos cargarla en el messenger (Ojo: versión 8.5):

Abrimos messenger -> Opciones -> Accesorios -> Agregar a messenger -> Buscamos nuestro assembly;

Y lo activamos desde el menú principal..

😀 y listo.

Las opciones con los agentes son muy divertidas y/o interesantes,
por ejemplo unos compañeros y yo hicimos uno que procesaba los mensajes
que recibia y mandaba una respuesta, hay uno que es de la Encarta el
cául te ayuda a hacer búsquedas, o por ejemplo uno (para mí muy útil
por cierto) que manda feeds de RSS.

Es cuestión de echarlo coco…

CUDA

 Hace algunos dias me tope con una tecnología de nVidia llamada CUDA.
uhmmm ¿Para que sirve? básicamente para utilizar el procesamiento
many-core de los GPU’s.

Además los GPU’s modernos nos permiten desarrollar programas
utilizando vector programming, así como utilizar algunas “opciones
extra” a la hora de trabajar con floats…

Bien, a esto le vamos a agregar que podemos desarrollar nuestros programas en lenjuague C, e incluso integrarlo en varios IDE’s.

Hace un rato me puse a integrarlo en VC++ 2005 (Guía
) y todo funciona perfectamente (ea ojo, solo vamos a utilizar el
editor, para compilar necesitamos utilizar el compilador de CUDA)

Veamos un pequeño ejemplo pasado en C++


#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>

#define M_PI 3.14159265358979323846f

int _tmain(int argc, _TCHAR* argv[])
{
DWORD start = GetTickCount();
const int N = 200000;
float a[200000] = {0};

for (int i=0; i<N; i++)
a[i] = (float)i;


for (int i=0; i<N; i++)
a[i] =
sqrtf(sqrtf(cosf(a[i] / 1024 * (M_PI / 180.0f))) * sinf(1.0f)) *
sqrtf(sqrtf(cosf(a[i] / 1024 * (M_PI / 180.0f))) * sinf(1.0f)) *
sqrtf(sqrtf(cosf(a[i] / 1024 * (M_PI / 180.0f))) * sinf(1.0f));


DWORD end = GetTickCount();
printf("Processing time: %d %d (ms) n" , end - start);

system("PAUSE");
return 0;
}

Sencillo, simplemente creamos un array y le aplicamos operaciones a lo bruto (a lo bruto).

Ahora nuestro ejemplo portado a CUDA sería algo así:


#include <tchar.h>
#include <stdio.h>
#include <cuda.h>
#include <cutil.h>

#define M_PI 3.14159265358979323846

__global__ void kernel(float *a, int N)
{
int idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx<N) a[idx] =
sqrtf(sqrtf(cosf(a[idx] / 1024 * (M_PI / 180.0f))) * sinf(1.0f)) *
sqrtf(sqrtf(cosf(a[idx] / 1024 * (M_PI / 180.0f))) * sinf(1.0f)) *
sqrtf(sqrtf(cosf(a[idx] / 1024 * (M_PI / 180.0f))) * sinf(1.0f));
}


int main(void)
{
unsigned int timer = 0;
CUT_SAFE_CALL(cutCreateTimer(&timer));
CUT_SAFE_CALL(cutStartTimer(timer));

float *a_h, *a_d;
const int N = 200000;

size_t size = N * sizeof(float);
a_h = (float *)malloc(size);


cudaMalloc((void **) &a_d, size);

for (int i=0; i < N; i++)
a_h[i] = (float)i;

cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);


int block_size = 4;
int n_blocks = N/block_size + (N%block_size == 0 ? 0:1);


kernel <<< n_blocks, block_size >>> (a_d, N);


cudaMemcpy(a_h, a_d, sizeof(float)*N, cudaMemcpyDeviceToHost);
CUT_SAFE_CALL(cutStopTimer(timer));


printf("Processing time: %f (ms) n", cutGetTimerValue(timer));
CUT_SAFE_CALL(cutDeleteTimer(timer));

free(a_h);
cudaFree(a_d);
system("PAUSE");
}

Solo que esta pieza corre dos veces más rápido!! (AMD Athlon X2 vs
GeForce 8800 GTX) y eso que aún estamos contando el tiempo de creación
de datos que en realidad solo pasaría una vez en el programa.

¿En que es diferente el código?

El código en CUDA, tiene una función extra, esta función es nuestro
kernel, en otras palabras la función que cargaremos al GPU; esto es
elemental puesto que a todos los datos los vamos a procesar igual (como
en los shaders), ademas todos los datos debemos de crearlos en el host,
osea en la PC (ouch!! solo imaginen que la tarjeta de video esta
aparte) y en el dispositivo (la tarjeta de video que suponemos esta
aparte) y al hacer esto debemos de preocuparnos por su sincronización.

Este ejemplo es estupidamente sencillo, pero ahora imaginemos que
podemos procesar partículas (jejeje voy a hacer eso esta semana),
fluidos, física, u otro tipo de cosas donde el procesamiento es
elemental, sobre todo cuando vamos a aplicar una misma función a una
gran cantidad de datos (SIMD – Simple Input Multiple Data).

XNA + F#

 Cuando leí que al correr sobre .NET F# podía utilizar cualquier
libreria dije “ya lo veremos”, y vaya hasta el momento me ha funcionado
bastante bien y para muestra me puse investigar acerca de cómo demonios
meterle XNA… y es MUY SENCILLO 😀


#light

#I @"C:Program FilesXNAv2.0ReferencesWindowsx86"

#r "Microsoft.Xna.Framework.dll"
#r "Microsoft.Xna.Framework.Game.dll"

open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Graphics
open System

type XNAGame = class
inherit Game as base

val mutable graphics : GraphicsDeviceManager

new() as this =
{
graphics = null
}
then
this.graphics <- new GraphicsDeviceManager(this)

override this.Draw(gameTime) =
let gd = this.graphics.GraphicsDevice
gd.Clear(Color.CornflowerBlue)
end

let Main() =
let game = new XNAGame()
game.Run()

[<STAThread>]
do Main()

😀 😉 🙂 xD

Lo único de deben hacer es establecer el directorio donde tienen
alojado el XNA, en este caso la versión 2.0 pero también lo probé con
la 1.0 (oh si, mi version de F# es 1.9.3.14) porque tal parece que los
assembly no estan en el GlobalAssemblyCache, otra opción es configurar
el envoriment path (bucar en google) para poder acceder hasta él desde
la linea de comandos.

Para compilarlo utilizé el siguiente batch:


@if "%_echo%"=="" echo off
setlocal

......binfsc.exe xna.fs
if ERRORLEVEL 1 goto Exit

:Exit
pause
xna.exe
endlocal

exit /b %ERRORLEVEL%

Osea un compila y ejecuta.

Ya veré más delante que más le meto…

XNA HLSL

 El día de ayer (bueno la madrugada de hoy) hicé un pequeño screencast
acerca de shaders en XNA, les dejo el video y el link para descargar el
código.

 

 

 

Tambièn les dejo la imagen de la escena lograda con este tutorial. 😀



Bloom Cubemap

 

HLSL Shaders: Ejemplo en XNA

Hay una parte muy cool de cuando programar gráficos se trata, esa parte
es el utilizar el GPU (Graphics Processing Unit) ósea la mismí­sima
tarjeta de video para hacer cálculos y almacenamiento de memoria.

La Content Pipeline

Actualmente existen lenguajes de alto nivel (Cg de nVidia, HLSL de
Microsoft y GLSL para OpenGL) que básicamente funcionan de la siguiente
manera:

Content Pipeline

Primero obviamente lo que necesitamos es crear un shader, este lo
podemos hacer desde Visual Studio, o utilizando un programa de autorí­a
de shaders como el Render Monkey de ATI o FX Composser de nVidia, este
archivo lo vamos a cargar en nuestra aplicación y la API gráfica se
encargará de que la tarjeta de video lo compile en tiempo real, esto se
hace para crear una optimización para cada tipo de hardware.

Una vez hecho esto nosotros generamos un conjunto de vértices
(estos pueden ser por ejemplo un modelo 3D) activamos el shader desde
nuestra aplicación y cuando el GPU realice los cálculos para la
proyección tomará en cuenta los parámetros y métodos del shader;
después nuestra los drivers convertirán esa salida generada (aún 3D) a
coordenadas de pantalla, este proceso se le conoce como rasterización,
con nuestros objetos proyectados en la pantalla podemos modificarlos
una vez más, esta vez pí­xel a pí­xel. 😀
Ejemplo

Supongamos que tenemos el siguiente código en un archivo .fx,
podemos crear estos archivos dando click derecho en nuestro explorador
de soluciones y en agregar nuevo Effect:

Código en Effect1.fx:

//Estas variables representan las matrices de posición de nuestro objeto
//la matriz de nuestra camara, y nuestra proyección
float4x4 World;
float4x4 View;
float4x4 Projection;


//Esta estructura indica que es lo que va a tomar el shader
//En este caso solo tomara la posición del vértice, podemos agregar
//las coordenadas de textura, normales, colores, etc.
struct VertexShaderInput
{
float4 Position : POSITION0;
};

//Esto es muy parecido a la estructura de entrada, pero aquí­ especificamos
//que queremos que devuelva nuestro método
struct VertexShaderOutput
{
float4 Position : POSITION0;
};

//Esta función es nuestro vertex shader
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output;

//Sólo aplicaremos una sencilla transormación
float4 worldPosition = mul(input.Position, World);
float4 viewPosition = mul(worldPosition, View);
output.Position = mul(viewPosition, Projection);

return output;
}

//Esta función es nuestro pixel shader
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
//Aquí­ especificamos que queremos que para todo ­xel
//que se dibuje lo pinte de color rojo :)
//podemos por ejemplo regresar el valor de una textura respecto
//a la coordenada actual
return float4( 1, 0, 0, 1);
}

//Aqui especificamos nuestras técnicas
//un archivo fx puede tener varias técnicas
technique Technique1
{
//Para cada pasada especificamos que funciones vamos a llamar
//y ademas debemos de decirle bajo que perfil se compilarán
pass Pass1
{
VertexShader = compile vs_1_1 VertexShaderFunction();
PixelShader = compile ps_1_1 PixelShaderFunction();
}
}

Para utilizarlo vamos a modificar nuestra clase Game1.cs:

Primero, vamos a declarar dos objetos en nuestra clase, uno para el modelo que utilizaremos y otro para nuestro efecto:

Model _model;
Effect _effect;

Después vamos a modificar nuestra función LoadContent() para poder cargar nuestros archivos:

        protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);

_model = Content.Load<Model>("model");
_effect = Content.Load<Effect>("Effect1");

///Esto va a quitarle el efecto actual al modelo y establecera el que
///le estamos asignando
foreach (ModelMesh mesh in _model.Meshes)
foreach (ModelMeshPart part in mesh.MeshParts)
part.Effect = _effect;

// TODO: use this.Content to load your game content here
}
protected override void Draw(GameTime gameTime)
{
graphics.GraphicsDevice.Clear(Color.CornflowerBlue);

float aspectRatio = graphics.GraphicsDevice.Viewport.Width /
graphics.GraphicsDevice.Viewport.Height;


//Definimos la tecnica
_effect.CurrentTechnique = _effect.Techniques["Technique1"];

_effect.Parameters["World"].SetValue
(Matrix.CreateWorld(Vector3.Zero, Vector3.Forward, Vector3.Up));
_effect.Parameters["View"].SetValue
(Matrix.CreateLookAt(new Vector3(0.0f, 5.0f, -10.0f), Vector3.Zero, Vector3.Up));
_effect.Parameters["Projection"].SetValue
(Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f),
aspectRatio, 1.0f, 10000.0f));

//Actualizamos el shader
_effect.CommitChanges();

foreach (ModelMesh mesh in _model.Meshes)
foreach (Effect effect in mesh.Effects)
mesh.Draw();


base.Draw(gameTime);
}

Por último vamos a dibujar nuestro modelo con el shader
correspondiente y el resultado debe de ser el modelo dibujado
completamente en rojo, y esta es la imagen de nuestro primer shader:

¿No es interesante? Bueno, es nuestro “hola, mundo!” de los
shaders, así­ que de aquí­ podremos partir a cosas más interesantes
como iluminación, a continuación les voy a presentar una imagen de un
render un poco más complejo:

Este render contiene 3 shaders, uno para los reflejos del agua,
otro para el brillo de la nave, y otro que le da un efecto de zoom
radial. 🙂

Conclusiones

Los shaders se utilizan para prácticamente todo el procesamiento
de gráficos, algunas aplicaciones lo manejan automáticamente pero si
quieres tener el control completo y agregar efectos a tus aplicaciones
gráficas la mejor manera es meterle mano.

Los shaders no solo se utilizan en videojuegos o aplicaciones 3D,
también se utilizan en edición de imágenes o ví­deo, en un futuro
tutorial hablaré de como crear shaders de post producción (como los que
se utilizan para las pelí­culas).

 

SceneGraphs en XNA

 Hoy en día cuando queremos hacer un videojuego relativamente grande con
gráficos 3D es muy complicado manejar los objetos necesitamos
actualizar de uno por uno, para resolver este problema existe una
estructura de datos muy utilizada llamada SceneGraphs, que básicamente
son estructuras que almacenan toda la información de manera jerárquica
dentro de un grafo o árbol y nos permite “olvidarnos” de cada objeto,
ya que esta estructura se encargará de clasificarlos y manejarlos
automáticamente.



Bloom Cubemap


Para este ejemplo vamos a utilizar una implementación muy sencilla
que solo requerirá que almacenemos nuestros datos dentro de una
colección linear de elementos esto es que cada nodo contendrá solamente
un nodo hijo, con esto vamos a poder viajar a través del SG por medio
de iteraciones lineares.

Durante estos recorridos nosotros vamos a poder actualizar el
estado de nuestro SG, y además vamos a poder dibujar el contenido que
necesite ser mostrado.



Bloom Cubemap


En nuestro ejemplo cada nodo representara un elemento gráfico del
juego, este elemento puede ser un modelo, un terreno, un shader, un
sistema de partículas, en fin, prácticamente cualquier objeto que
podamos dibujar en la pantalla, claro en este ejemplo nos limitaremos a
un modelo 3D.

Para esto lo primero que debemos de definir es nuestra Clase
Objeto, que es la clase base de donde partirán todas las entidades, en
este caso vamos a dejarlas con los elementos más comunes, a su vez
vamos a crear una clase Modelo la cual será heredará a la clase objeto
y tendrá implementada una interfaz IRendereable, que nos permitirá
saber que nuestro modelo se puede dibujar.



Bloom Cubemap


Por ahora el elemento model es el único que vamos a utilizar en
nuestro SG, así que vayamos a la parte interesante de este tutorial, el
scene graph:



Bloom Cubemap


Como podemos observar en el diagrama anterior nuestro SG contine un
nodo principal que será nuestra raíz, y un método que nos permite
agregar más elementos al mismo, después tenemos nuestra clase que
contiene la información a nuestra clase object, de la cual se derivan
todas las clases que podemos ingresar al SceneGraph para se dibujas,
además tenemos una clase que es el nodo básico de cada escena, esta
clase nos permite accesar a los nodos de nuestro SG para poder hacer
las llamas a los objetos correspondientes a cada nodo.

:D, El código esta disponible en mi skydrive por si alguien quiere hecharle un ojo 😉

LINQ to XML – El ejemplo de C#

 LINQ (Language INtegrated Query) es un conjunto de clases que como su
nombre lo dice, te permiten hacer consultas a nivel nativo (dentro de
C# y VB.NET) a datos que pueden provenir de un arreglo, de una base de
datos relacional, declases enumerables o como lo veremos en este
pequeño ejemplo de XML. 😀

Supongamos que tenemos el siguiente XML en una cadena llamada xmlString:

<root>
<var>
<tag>atributo1</tag>
</var>
<var>
<tag>atributo2</tag>
</var>
</root>

Para leer todos las varibles simplemente hacemos una consulta con LINQ en un stilo muy similar a como la realizariamos en SQL:

XDocument data = XDocument.Parse(xmlSring);

var elements = from c in data.Descendants()
select c;

foreach (var c in data.Descendants("var"))
Console.WriteLine(c.Element("tag").Value);

Este código mostrara en lineas separas todos los elementos “var”.

Ahora, supongamos que queremos agregar mas elementos “var”, lo único que debemos hacer es:

XElement newKey =
new XElement("var",
new XElement("tag", "Value")
);

data.Root.Add(newKey);
data.Save(_file);

Y listo 😉

Para mi gusto LINQ te permite ahorrar muchisimo tiempo, y además es
muy amigable, particularme a la hora de manejar XML ya que antes era un
tanto enredoso hacer consultas.