Valtovar

Algunos Trailers interesantes

2010-04-04T12:49:00.000-07:00

Ha pasado mucho tiempo desde que escribí la última vez en el blog. Pero el abandono no ha sido del todo mi culpa, pues he tenido problemas de salud desde hace casi dos meses que me impidieron desarrollar mis actividades normalmente.

Ahora POR FIN estoy mejor (aún no estoy totalmente curado) y creo que puedo retomar algunas actividades, entre ellas la actualización de este blog, y para retomar, nada mejor que un grupo de trailers de algunos videojuegos bien bacanos

Esta lista será donde ponga los trailers que vaya viendo, seleccionados por mi.

Por otra parte, dos noticias importantes:

Raknet ha publicado su versión 4, con muchas mejoras y ports para consolas next-get. UDK ha sacado la siguiente versión (Mayo) y dentro de sus nuevas características, la que mas me ha gustado es el soporte para ScaleForm, den una mirada pues es la herramienta mas potente para construir GUIs de juegos 3d y 2d (integra flash).

Por ahora no es mas, espero seguir actualizando el blog con la frecuencia que tenía antes.

Shamman Beast

2009-11-24T12:47:00.000-08:00

Es un nombre tentativo :D, es un videojuego, apenas estamos trabajando en la idea y algo de arte. En general narra dos historias:

--
Shamman Beast: Guerra

Es la "precuela", cuenta la historia del "Tigre" (aún no hay nombre para le personaje, pero su bestia es un Tigre), el co-protagonista de la historia del game, su ambientación está dada en un futuro cercano no muy distinto de nuestro presente, donde apenas se iniciaban las peleas entre paises, guerras por recursos mas importantes que el dinero. Explica diversas situaciones que dieron inicio a una guerra, algo muy común ya en los videojuegos. La historia es narrada desde el punto de vista del protagonista quién es un muchacho latino que se va moviendo entre situaciones y a medida que va avanzando va tomando partido importante dentro del cause, paralelo a este tema se va dando la aparición del Shamman, esta parte de la histria aún es reservada.

En la historia el protagonista se enfrentará a diversos tipos de personajes que son importantes para la segunda parte como uno de los "Jueces" o uno de los "Cazadores".

Bueno esto es simplemente la presentación de la primera parte de la historia, nada detallado.
--

--
Shamman Beast: Paz

Esta será la segunda entrega de la misma historia, aca el "Tigre" ya no será el protagonista, pues él ya hizo su función que era ayudar a generar la guerra, ahora será su hija la que debe llevar con los pecados de su padre. Al igual que el padre también posee el poder de la invocación de espíritus de bestias por instantes, es un shamman. Esta parte de la historia se da un poco mas adelante de nuestro presente, con una sociedad avanzada y degradada por dicho avance. Por ahora no hay mas para contar. Esta es la historia del primer juego.

El desarrollo contará con ciertos tipos de jugadores:

Los Ciberpunks: personajes que usan la tecnología para lograr lo que los shammanes consiguen espiritualmente.
Los Shammanes: personajes que han aprendido el arte de la invocación de espíritus y fuerzas de la naturaleza.
Los Cazadores: Son personajes que conocen el arte shamman y que lo han perfeccionado bastante, en casi todas sus cualidades son superiores a los demás, generalmente solitarios
Los Jueces: Son personajes que nacen siendo dioses, con todo su poder desarrollado, pueden realizar invocaciones de animales que no existen (bestias míticas) o animales extintos.

Por ahora estamos puliendo la historia de la segunda parte y la primera (en ese orden :D) y estamos trabajando en algunos artes que voy a poner aca (son imagenes de alta así que pesan un poco xD):

[Cazador]

[Ciberpunk]

Assassins creed movie

2009-11-19T15:08:00.000-08:00

Se trata de la película que hizo la gente de ubisoft para contar la historia previa al momento en que se desenvuelve la segunda entrega de este videojuego, altamente recomendado.

Yo se que no encaja pero me da igual¡¡¡

2009-11-11T21:00:00.000-08:00

Si lo se, el blog tiene un sentido mas informativo y técnico pero me vale, un par de canciones ke voy a compartir aca ahora mismo (son 4 ¬¬)

Recomendadas:
http://www.youtube.com/watch?v=TmFi2snLr7o
http://www.youtube.com/watch?v=mpiEEl_5pmA

--

Nuevo proyecto: "Road Gunners"

2009-11-10T14:46:00.001-08:00

En una tarde de aburrimiento, oir música depresiva jajajajajajaja y sentirse algo triste y con la cabeza vuelta nada surgen algunas buenas ideas ... y esta definitivamente es una de ellas, he decidido con Felipe (cafeino o Cafeortiz) iniciar un nuevo proyecto que tiene por nombre tentativo "Road Gunners"

¿En qué consiste?
Pos vamos a elegir un fin de semana del mes para ir a algún lugar de Colombia, vamos a tomar fotos, vamos a escribir una encuesta que pronto publicaré y la haremos en cada destino, filmaremos la vida nocturna y diurna durante solo uno o dos dias. Vamos a crear un blog para el proyecto y en él vamos a publicar cada mes el contenido nuevo que consigamos en dicha ciudad con nuestros comentarios y demás.

¿Objetivo?

La verdad ninguno que tenga mucho sentido, es que estabamos hablando de las distintas regiones y la gente de cada una y pos nos surgió la idea de viajar a conocer para dejar de especular tanto :P

¿Cuándo inicia?
En diciembre daremos inicio a nuestros viajes jajajajaja :P

¿Cuál es el primer destino?

Pos teniamos varias opciones pero creemos que la mejor para iniciar es Manizales así que estaré avisando la fecha del viaje pronto :P.

¿Algo mas?
No nada mas, too bien calmate calmate ...

Unreal Engine 3 Eval Kit FREE

2009-11-05T10:53:00.000-08:00

Bueno es una noticia de la que hay que hacer ECO en todos lados, la gente de Epic Games ha decidido liberar su eval kit de desarrollo totalmente gratis para uso no comercial (incluye realización de demos y fines académicos), para los que aún no alcanzan a darse cuenta de la magnitud de la noticia, esto significa ke los desarrolladores independientes YA tienen una herramienta para desarrollar una demo de su juego FULL con TODO y con la tecnología de PUNTA, esto con el fin de una vez terminada la demo poder buscar patrocinio mas fácilmente, en CONCLUSIÓN, ya no hay excusas de adquisición de tecnología pues puedes usar la de PUNTA para tu desarrollo.

Para mi adicional tiene una implicación mas y es que ahora podré actualizar el programa de "Diseño de Videojuegos" que dicto en la universidad ICESI de Cali para cambiar la plataforma sobre la cual trabajemos, de JME a UE3, esto con el fin de enseñar a los estudiantes a trabajar sobre las herramientas que se usan en el mercado ... lo que yo llamaria estandar de facto.

En definitiva esta noticia trae grances cosas para todos y para mi en particular :P.

Link a la noticia en gamasutra: http://www.gamasutra.com/php-bin/news_index.php?story=25955

Link al url del site oficial de UDK (Unreal Development Kit): http://www.udk.com/

Pongo aca la traducción del mini-FAQ que han puesto en el sitio oficial del proyecto:

--
¿Puedo crear cualquier tipo de juego en el UDK?
Absolutamente. UDK es la solución perfecta para cualquier tipo de mundo virtual que desees crear, desde un juego de carros hasta simulaciones. Visita nuestros "showcase" para ver algunas de las asombrosas creaciones de nuestros usuarios con UDK.

¿Puede mi programa UDK correr en Mac, iPhone, PS3 o Xbox 360?

Justo ahora, UDK es un programa unicamente para Windows. Por favor visita nuestra página de licenciamiento si deseas hablar sobre el uso de UDK para multiples plataformas.

He realizado mods para Unreal Tournament 3. ¿Cuanto difiere UDK del editor de UT3?

Puedes crear aplicaciones independientes (de escritorio) con UDK. Esto significa que los usuarios podrán instalar y ejecutar tus juegos sin tener una copia del UT3.
--

Para finalizar este post dejo los requerimientos necesarios para ejecutar este sistema.

--

Minimos:

Windows XP SP2 o Windows Vista
Procesador 2.0+ GHz
2 GB de RAM
Tarjeta de video compatible con SM3
3 GB de Disco Duro libres.

Recomendados:

Windows Vista 64 SP2
Procesador multi-nucleo de 2.0+ GHz
8 GB de RAM
NVIDIA de la serie 8000 o superior
Todo lo que puedas de DD libre.

Parece ke tengo buena suerte, justo me llega el portatil Alienware y Epic libera este evalkit de desarrollo mmm creo que pasaré mucho tiempo con mis nuevos juguetes :D.

En un próximo post hablaré sobre lo que trae y lo que no trae el UDK, esta noche a instalar :D.

Bye bye

Algunas viejas cosas

2009-11-02T09:19:00.000-08:00

Estoy en este momento ordenando mis cosas y revisando unos cds he encontrado tres viejos artículos que intenté escribir hace como 6 años ya, dos están terminados y otro está solo a medio camino, igual los estoy publicando en este post ya que puden ser de utilidad para alguien y sino igual para recordar viejos tiempos :D.

-------
Sockets en Tcl.
--------------------

Este es mi tercer artículo, Hace un año aprendí a programar en este lenguaje debido a que lo necesitaba para una materia y la verdad me parece muy bueno, es lenguaje script pero es muy bueno. En este artículo se intenta explicar como trabajar con sockets en Tcl de una forma fácil y rápida.

INDICE
-----------

- Introducción

- Abriendo un Socket como Servidor

- Abriendo un Socket como Cliente

- E/S asíncrona con Sockets

- Demo

- Despedida

-------------------------------------------------------------------------------

- Introducción.
-------------------

Los sockets son usados en todo tipo de programa en red, para comunicar dos computadores o dos programas en la misma máquina. El modelo de Socket es muy usado en redes TCP/IP. Algunos programas como "servidores" escuchan en un puerto particular. Cuando algún programa como "cliente" inicia una conección, el "servidor" responde y comienza a leer la información del cliente, y escribe información cuando es necesario. Muchas de las operaciones de lectura y escritura son a la salida/entrada estandar o sobre archivos, pues esta operación es exactamente la misma sobre sockets.

- Abriendo un Socket como Servidor.
------------------------------------------------

Código ejemplo:
set trigger 0
set s [ socket -server openchan 5000 ]
vwait trigger

Explicación:
La segunda línea abre un socket sobre el puerto 5000; cuando el cliente se conecte el argumento "-server" es invocado y en este caso se ejecuta el procedimiento "openchan". Los parámetros del manejador de archivo para la conección, la dirección y el puerto del cliente son automaticamente pasados. La tercera línea es "vwait" que suspende la ejecución del programa hasta que la variable "$var" cambie.

El procedimiento "openchan" debe recibir estos parámetros ( manejador de conección, puerto y dirección ) y decidir cual será la forma de comunicación entre cliente y servidor y la forma de retornar los datos.

- Abriendo un Socket como Cliente.
----------------------------------------------

Una vez creado el servidor y corriendo, basta con hacer:

valtovar@dintev articulos $ nc localhost 5000

Para darnos cuenta de que funciona perfectamente, sacará un error debido a que aún no hemos escrito la función "openchan" la cual debe estar antes del socket para que entre en el "scope" del socket, pero esto indica que la conección fue exitosa.

Una vez testeado nuestro servidor continuamos con el cliente. Muy seguramente deseamos que nuestro cliente realice algunas funciones, pues aquí está el código de un simple cliente que solamente abre una conección y escucha.

set s [ socket localhost 5000 ]
while { [ gets $s line ] != -1 } {
puts $line
}

- E/S asíncrona con Sockets.
------------------------------------

Ahora si mostraré nuestra función "openchan" la cual debe estar del lado del servidor

proc openchan { chan dir puerto }
{
% setea flags para el canal de comunicación.
fconfigure $chan -blocking 0 -buffering none

% ejecuta cuando hay datos para leer en el canal.
% es importante para recibir y atender a cada cliente.
fileevent $chan readable "readchan $chan"

% imprime del lado del servidor.
% $chan es el manejador de conexion.
% $dir es la direccion del cliente.
% $puerto es el puerto del cliente.
puts stdout "Conexión aceptada $dir:$puerto ( $chan )

% imprime del lado del cliente.
puts $chan "Servidor leyendo"
}

En la línea 2 se configura el canal de comunicación con algunos flags; "blocking" es para que el canal sea blokeante o no, en nuestro caso, es no blokeante. Es necesario colocar fileevent debido a que como es no bloqueante, necesitamos que cuando existan datos en el canal para leer, se ejecute este script y los lea.

- Demo.
---------

Esta es un pequeño chat modo texto creado en tcl para demostrar el manejo de sockets, ejecuta el server.tcl primero y luego dos veces el client.tcl para que se vea en ejecucion.

- Despedida.
---------------

Bueno, con esto termino la versión 0.1 de mi artículo el cual se limita a explicar de forma muy basica el uso de sockets en tcl, para proximas versiones voy a colocar mas tips interesantes sobre el manejo de sockets en tcl.

-------

El siguiente irá en otro post

Algunas viejas cosas II

2009-11-02T08:35:00.000-08:00

El primero fue de Sockets en Tcl, este será el segundo artículo que escribí hace como 6 años, este es sobre estructuras de datos en C++, Java y Python, me hubiera gustado terminarlo :D.

------
Estructuras de Datos en C++, Java y Python
-----------------------------------------------------------

Este articulo esta dirigido a aquellas personas que tienen un conocimiento sobre lenguajes de programacion y que desean aprender un poco mas sobre ellos y sobre como mejorar sus programas mediante el uso de estructuras de datos mas complejas. En este articulo explicare en detalle algunas estructuras de datos ( las mas comunes ) y su implementacion en lenguajes de programacion como C++ y Java; sobre los algoritmos de manipulacion sobre dichas estructuras y sobre como optimizar su uso.

En este articulo supongo que el lector tiene conocimiento en dichos lenguajes y debido a esto no hare mucho incapie en sintaxis ni explicaciones pertinentes al lenguaje, solo a las estructuras.

Contenido:
---------------

- Introduccion.
-- Estructuras Fundamentales.
--- Array.
--- Lista.

- Pilas.
-- Representacion.
-- Algoritmos de Manipulacion.
--- Push.
--- Pop.
--- Top.
--- Empty.
-- Implementacion en C++.
-- Implementacion en Java ( propia ).
-- Explicacion de la clase Stack de Java.
-- Implementacion en Python.

- Colas.
-- Representacion.
-- Algoritmos de Manipulacion.
--- Insert.
--- Delete.
--- Find.
--- Sort.
--- Empty.
-- Implementacion en C++.
-- Implementacion en Java.
-- Implementacion en Python.

- Listas Enlazadas.
-- Representacion.
-- Algoritmos de Insercion, Busqueda y Eliminacion.
-- Implementacion en C++.
-- Implementacion en Java ( propia ).
-- Explicacion de la clase LinkedList de Java.
-- Implementacion en Python.
-- Recomendaciones.

- Listas Doblemente Enlazadas.
-- Representacion.
-- Algoritmos de Manipulacion.
-- Implementacion en C++.
-- Implementacion en Java ( propia ).
-- Implementacion en Python.
-- Recomendaciones.

- Listas Circulares.
-- Representacion.
-- Algoritmos de Manipulacion.
-- Implementacion en C++.
-- Implementacion en Java ( propia ).
-- Implementacion en Python.
-- Recomendaciones.

- Arboles
--
- Grafos

- Tablas Hash

-------------------------------------------------------------------------------

- Introduccion:
---------------------

Las estructuras de datos se basan en la teoria de conjuntos. Son agrupaciones de datos con caracteristicas comunes para su facil manejo. Existen dos tipos de estructuras de datos conocidas como "Estructuras Fundamentales" que son: Array y Lista, Son las mas faciles de manipular debido a que no existen sobre ellas ningun tipo de restriccion, por tanto los procesos de "Consultas y Modificaciones" son mucho mas faciles; muchas de las estructuras mas complejas
como pilas o colas son implementadas en base a estas dos, son como arrays con restricciones de acceso o modificacion.

La desventaja de la estructura Array es que es estatica, su tamaño debe ser fijado en tiempo de compilacion para la reserva de la memoria, mientras que las Listas permiten hacer reserva de mas memoria en tiempo de ejecucion de un programa, por tanto son dinamicas y pueden crecer con forme pasa el tiempo de ejecucion mientras que el array permanecera estatico durante dicho tiempo. En ambas estructuras no existe forma de saber si un dato se encuentra almacenado a menos que se haga un recorrido por toda la estructura y esto en cualquier caso tomara "Theta ( n )" ( se lee teta de n ) donde "n" es el tamaño de la estructura ( la cantidad de datos ) por tanto si "n" es muy grande esta busqueda seria demasiado costosa en tiempo. Por otro lado, Buscar
un elemento en la lista siempre sera "Theta ( n )", mientras que en un Array puede ser "Theta(1)" debido a que tiene un comportamiento parecido a una Tabla Hash, lo que permite hacer un accesado directo al dato buscado si tenemos la "llave" ( key ), en el caso de los Arrays dicha "llave" es el indice en el cual se encuentra el elemento. Para que quede mas claro muestro un ejemplo:

Tenemos dos estructuras:

Array [ n ]; // n es la cantidad de elementos.
Lista.p = 0; // La estructura Lista tiene dos campos: p -> int,
Lista.next = Lista // next -> puntero al siguiente elemento de la lista ( lista enlazada ).

Inicializamos las estructuras.

for i <- 0 to n // para i desde 0 hasta n.
Array [ i ] <- ( i + 1 );
Lista.p <- ( i + 1 );
Lista <- Lista.next;
Lista.p <- infinito;
Lista.next <- null;

Si queremos saber si 9 esta en la lista tocaria:

for i <- 0 to n
if Array [ i ] == 9
print "Esta en la pocision: " i;
else print "No esta";

i <- 0;
while Lista.next != null
if Lista.p == 9
print "Esta en la pocision: " i;
else Lista <- Lista.next;
i++;

Como se ve, en ambas toca hacer una busqueda en toda la estructura hasta encontrar el elemento buscado. Ahora miremos otras operaciones:

Si queremos insertar un elemento:

Array [ k ] <- elemento // k es la pocision donde lo vamos a insertar.
ptrLista.p <- elemento // ptrLista es un puntero a la ultima pocision
ptrLista.next <- null // de la lista.

Esta operacion es rapida y no toma mucho tiempo si tenemos en ambos casos una variable externa que nos indique en donde vamos en la estructura ( en Array es "k" y en Lista es "ptrLista" ), en caso contrario tocaria hacer de nuevo una busqueda por toda la estructura para encontrar el final e insertar ahi el nuevo elemento.

*********************************************************************************

Tip: Es bueno tener dicha variable externa en caso de realizar varias operaciones de este tipo sobre la estructura para ahorrar en tiempo de ejecucion.

*********************************************************************************

Ahora veamos que pasa cuando buscamos un elemento en una determinada pocision:

print Array [ k ]; // k es la pocision del elemento.

i <- 0;
while Lista.next != null
if i == k
print Lista.p;
else Lista <- Lista.next;
i++;

Como vemos, en el Array hay un acceso directo por tanto el tiempo es Theta(1) mientras que en Lista hay que hacer una busqueda por toda la estructura, haciendo que su tiempo en el peor de los casos sea "Theta(n)".

Una vez visto la introduccion a estas estructuras basicas, entremos en materia. La estructura Lista sera explicada mas adelante.

-------------------------------------------------------------------------------

- Pilas ( Stack ):
----------------------

Esta es una de las estructuras mas simples que existen, es generalmente implementada basandose en Array o Lista a las cuales se le aplican las restricciones necesarias para que se comporte como lo hace una pila ( LIFO, Last In, First Out ). La estructura de una pila responde al comportamiento de una pila de platos, donde se coloca uno, luego otro y asi sucecivamente hasta llegar a un numero "N" de platos apilados, luego cuando se desea obtener un plato en la pocision "X" ( 0 < style="font-style: italic;">Ultimo en llegar, Primero en Salir y es asi pues para obtener el ultimo plato primero deben retirarse los N-1 platos que estan encima de el ultimo.

Ejemplo:

N = 3, TotalPlatos = 1.
Pos = 1 = X

N = 3, TotalPlatos = 2.
Pos = 1 = X
Pos = 2 = X

N = 3, TotalPlatos = 3.
Pos = 1 = X
Pos = 2 = X
Pos = 3 = X

Como se ve en el ejemplo, el ultimo en llegar queda ubicado en el tope de la pila y el primero va quedando "cepultado". Ahora si desdeamos obtener el tendriamos que retirar primero el para luego obtener el , asi: "X = 2", retiramos los "X - 1 = 2 - 1 = 1" platos antes que hay encima de él, o el , hariamos: "X = 3" y "3 - 1 = 2" platos que se
deben retirar primero.

******************************************************************************

Tip: en la computadora las pilas no se llenan hacia arriba como una pila de platos, se llenan es hacia abajo, por eso en la pila de datos de un programa, los parametros a funciones se pasan de forma inversa a la que son enviados asi, si tenemos:

function algo ( par1, par2 ),
en la pila veriamos:

// Sentido inverso al que nosotros lo enviamos.

y al retirar el elemento del tope tendriamos:
// El ultimo elemento era

Esto por que supone que el orden importa y el elemento que se pasa de primero se va a utilizar de primero, asi que lo pone de ultimo en la pila para poder acceder de inmediato a ese elemento.

******************************************************************************

En este tipo de estructuras existen dos operaciones que son insertar conocida como PUSH y eliminar llamada POP, tambien es comun encontrar una tercera funcion para ver el ultimo elemento de la pila sin eliminarlo llamada TOP. En muchas implementaciones como en la de Stack de Java encontramos otras funciones como EMPTY y FULL para saber si la pila esta llena o vacia, ahora vamos a estudiar estos algoritmos en detalle.

-- Algoritmos de Manipulacion.
----------------------------------------

- Push
-------

Push ( x )
Tope () = Tope () + 1 // Incrementa el tope de la pila.
Pila ( Tope () ) = x // Almacena el nuevo elemento en el tope de la pila.

- Pop
------

Pop ( )
Tope () = Tope () - 1 // Decrementa el tope en 1.
Return Pila ( Tope () + 1 ) // Devuelve el elemento que se retiro para mostrarlo.

En el algoritmo Pop se ve que solo se decrementa el contador del tope, esto es por que no hace falta eliminarlo realmente debido a que cuando se vaya a insertar un nuevo elemento, solo hace falta tener el tope, incrementarle 1 y ahi se sobre-escribe el dato. Asi como funciona el "rm" de las computadoras que no elimina realmente, solo etiqueta con "libre" y luego cuando va a guardar sobre-escribe.

Obviamente se puede mejorar estos algoritmos para evitar overflow y underflow pero esta es como la implementacion basica; la complejidad de estos dos es O(1) debido a que son operaciones que toman tiempo constante.

*********************************************************************************

Tip: En estas estructuras de datos hay dos tipos de vulnerabilidades que son:
underflow: cuando se desea retirar un elemento y la pila esta vacia. Este error es tipicamente tratado.
overflow: cuando se desea insertar un elemento y la pila esta llena. Este error no se trata con frecuencia es un topico importante en la validacion de seguridad de un programa. Genera un bug que puede ser explotado.

********************************************************************************
-------

Por desgracia este artículo lo dejé hasta ahí, espero sirva de algo para alguien jajaja. Gracias :P

Nuevo PC y Nuevo Motor jajajaj

2009-10-30T09:28:00.000-07:00

Buenas buenas, esta semana ha sido bien interesante ¬¬¬ un poco mas relajado pero tampoco tanto. Han sucedido dos cosas importantes y por eso es que he decidido poner este pequeño post:

1. Unity3d 2.6 ha sido liberado y para sorpresa de todos (incluyendome) fue puesto de uso libre para desarrolladores independientes, si así como lo leen, la versión Indie del motor es totalmente gratis (no opensource, gratis) y por tanto la podemos usar para desarrollar nuestras aplicaciones sin problemas. A todos les recomiendo que le den una mirada al motor ya que tiene de todo: network, ia, fisicas, render, editores para artistas, soporte de sonido, etc., en general es una muy buena opción para kienes kieren iniciar el en desarrollo de games ya que está listo para producción. Aca dejo el link de la noticia (yo ya lo estoy usando para un proyecto). http://unity3d.com/company/news.html#Unity-2.6-Released-And-Now-Free!

2. Ya llegó mi PC Alienware M17x, es un portatil WOW jejeje aunque no compré el mas alto porque era ya demasiado costoso. Tiene 4G de RAM DDR3, 1G de video GTX 260, 320g de DD 10.000 rpm, 17', sistema de reconocimiento facial para inicio de sesión y mil cosas mas :P, aunque hasta ahora no lo he podido utilizar mucho porque no he tenido tiempo e instalarle todo lo que necesito para ke sea productivo me llevará un dia completo ... espero este fin de semana poder hacerlo e instalarle también el FEAR2 (que también me llegó ya :P) para probar como va con juegos y hacer un review de la máquina. Lo que puedo adelantar es que en lo poco ke lo he podido utilizar está de lujo y va muy bien :D (salvo por el peso, 5kilos solo el PC, + cargador :S).

Aca está el link del PC (el mio es negro): http://www.dell.com/content/products/productdetails.aspx/laptop-alienware-m17x?c=us&l=en&s=dhs

Bueno no es mas por el momento, mas rato subo imagenes del PC.

Un video para todos jajajajajaj a los 26 años creo que es normal pensar en algo como esto:

Imagenes de productos

2009-10-26T16:50:00.000-07:00

Bueno ahora si, aca están las imagenes de los 4 productos con tipografia, nombres y textos, en fondo negro y blanco. Necesito ayuda para elegir cual quedará entre las opciones:

Necesito URGENTE decidir entre las dos opciones que planteo en el gráfico, arriba está el smile con el nombre y abajo está un esquemático de cada mascota con el nombre, la idea es elegir entre smile o esquemático de mascota, por favor ayuda.

Blancos:

Nueva imagen y logos

2009-10-18T16:38:00.000-07:00

Bueno estamos retomando varios proyectos como Baphome, Iwana y otros y hemos trabajado en sus imagenes nuevas. En este caso hemos decidido trabajar los logos con animales y ya tenemos los siguientes resultados:

[Baphomet Game Engine]

Este es el logo de Baphomet Engine, un game engine para juegos 3d que ya tiene varias características de re-diseño como soporte para multiples núcleos, sistema de plugins independiente del Core del Engine, entre otros.

[Hidra Server]

Este corresponde a Hidra Server, un servidor escrito en C++ para aplicaciones cliente - servidor, incluye una API para AS3 para creación de clientes en Flash.

[Iwana Isometric Game Engine]

Iwana, el más dinámico jejejeje, la verdad este si que nos gustó, Es un motor para juegos en flash isométricos, tiene manejador de recursos, render, físicas 2d, sistema de módulos (similar al sistema de plugins), manejador de escena (isométrico) y un componente para network que funciona con Hidra Server aunque se puede migrar a cualquier otro tipo de servidor.

Bueno estos son los genéricos, cada uno de ellos genera un conjunto de sub-sistemas que se puede utilizar de manera independiente, por ejemplo, en el caso de baphomet, el sistema de multi-hilo o el de plugins, incluso el motor de físicas, cada uno de ellos son sistemas independientes que pueden ser utilizados para cualquier otro desarrollo y cada cual tendrá una imagen propia dentro de la especie que se ha elegido para el sistema grande.

Bueno pido comentarios o sugerencias. Gracias

Proyectos: Mazda 6 Colombia

2009-09-30T09:19:00.000-07:00

Bueno luego de mucho trabajo logramos terminar el site de Mazda 6 Colombia. Yo participé como director y ensamblador del site en la parte técnica. Fue un proyecto grande y complejo pero se logró realizar con resultados satisfactorios para todos y debido a esto pongo este post y el link del site, algunas capturas:

Link: http://www.mazda6.com.co/

El proyecto se realizó en flash y es 3d 100%.

Capturas:

Universidad de California: carrera de videojuegos

2009-09-23T20:32:00.000-07:00

Como soñar no cuesta nada pues he soñado que estudiaba algo en algún lugar en otro país (por desgracia aca en Colombia no encontraría algo similar a esto) y pues me dió como por dar una MUY básica búsqueda en internet en el site de la universidad del Sur de California (Universidad privada, cosa rara, allá las mejores son privadas, mientras que en nuestro país las mejores son públicas :D, dato curioso) en la facultad (escuela) de informática y ciencias de la computación y me he topado con algo de material bien curioso o mas bien interesante que he decidido compartir con aquellos lectores que entran aca:

Esta universidad tiene un enfoque hacia los videojuegos en sus carreras de ingeniera de sistemas (ciencias de la computación realmente) y diseño (no se si lo ofrezcan en otros planes), según alcanzo a entender la carrera es tal cual la vemos en una universidad tipo UniValle en Cali pero con un enfoque hacia los video juegos y todo el mundo del entretenimiento digital.

Hay que hacer notar que estos enfoques están patrocinados por empresas privadas del sector como Microsoft, E.A., entre otras grandes de la industria; llegados a este punto salta a la mesa la pregunta: ¿en qué momento las grandes marcas de Colombia que CIERTAMENTE tienen el capital para invertir en esta industria se darán cuenta de lo que dejan de ganar por no apostarle a algo nuevo pero igualmente gratificante?

Además de esto hay muchas otras dudas malucas que surgen por lo menos en mi cabeza y es por ejemplo: ¿Por qué las Universidades de nuestro País, o mas bien quienes las direccionan no se dan cuenta de que la "academia" no lo es todo? refiriendome a "academia" como la teorización de las cosas que todos (ings. de sistemas) recibimos; Para dar un ejemplo claro y sencillo: recuerdo que cuando ví "computación gráfica" en la Universidad del Valle (en cali, la sede principal), lo que vimos fue un resto de teoria y formulación que listo, hay que tenerla ya que no podría hacer un juego básico de cubos si no se sobre vectores, matrices, quaternions, vistas, clipping y demás cosas (la mayoría no las vi en dicho curso) pero adicional a esto uno como estudiante quiere ACCIÓN, quiere ver todas esas fórmulas chimbas funcionando en algo GRÁFICO, no mas demostraciones que cualquiera encuentra en un libro de matemática o en la wikipedia, seguro sin ellas no existiría la computación gráfica pero NO MAS¡¡¡, queremos pasar a la acción, si alguien quiere ver la demostración de porqué X = Y entonces la puede encontrar en el libro guía o en wikipedia y listo.

La verdad es que la academia te da muchas bases teóricas pero no te prepara para el mundo real, se enfoca demasiado en cosas de hace 20 años que ya casi nadie usa porque son base de la actualidad pero NO SON ACTUALIDAD y las cosas nuevas no las vemos, es mas, en la mayoría de casos NI te enteras de que existen :'(, de verdad que esto es una lástima.

Las universidades tienen muchos recursos que desperdician (creo yo), deberían montar cursos rápidos (diplomados por ejemplo) de cosas PRÁCTICAS y REALES como seguridad en redes móviles, administración de servidores, desarrollo web REAL, desarrollo de aplicaciones para móviles, desarrollo de video juegos (:D) y otras tantas cosas que uno tiene que aprender a la mala en la calle para poder trabajar. No importa si no es algo certificado académicamente, estoy seguro de que muchas personas de diversos perfiles desde amateurs hasta profesionales estarían interesados en un curso X de Y horas dictado por W, V, Z personas que son EXPERTAS en el tema. En conclusión, creo que es una verdadera lástima y desperdicio de talento que no es pasado de una persona a otra y que generalmente muere con los pocos que lo poseen (y a quienes les ha costado mucho conseguirlo).

Lo anterior es como una queja jajajaja, ahora una noticia, en la empresa con la que estoy trabajando ahora estamos pensando en abrir unos cursos sobre diseño y desarrollo de videojuegos y seguridad (algunos temas), esta info la estaré publicando mas adelante cuando sea el momento. Por ahora pues puedo anticipar que serán cosas UTILES y REALES usadas mucho en la industria REAL y que posiblemente no contemos con una certificación académica pero a término personal, creo que no es necesaria.

Ahora si lo importante de este post:
En la página de esta universidad encontré que ellos SI ofrecen estos cursos "rápidos" y PRACTICOS sobre cosas del AHORA (no de hace 20 años) y pues he decidido compartir algo de información con ustedes:

La página "principal" es: http://itp.usc.edu/courses/video_game

Otros links mas directos:

Programa completo de "desarrollo de videojuegos" (materias, créditos, etc.): http://gamepipe.usc.edu/bachelors.html

Cursos ofrecidos: http://itp.usc.edu/courses/video_game

Gráficos para videojuegos [PROGRAMA]: http://itp.usc.edu/files/itp481.pdf

Introducción a la programación de videojuegos [PROGRAMA]: http://itp.usc.edu/files/ITP%20380.pdf
Inteligencia Artificial en videojuegos [PROGRAMA - noten que usan Ogre como base del curso ya que es de I.A., no de render así que usan una herramienta de render ya creada]: http://itp.usc.edu/files/itp461.pdf
Juegos multi-jugador [PROGRAMA]: http://itp.usc.edu/files/itp484.pdf
Diseño y desarrollo de niveles [PROGRAMA]: http://itp.usc.edu/files/itp491.pdf
Desarrollo de motores de videojuegos [PROGRAMA]: http://docs.google.com/Doc?docid=0ASN0P9xJIL_eZGdqZHJobjlfMzhmZm1iYm5jcQ&hl=en
Dispositivos móviles y consolas de videojuegos [PROGRAMA]: http://docs.google.com/Doc?docid=0ASN0P9xJIL_eZGdqZHJobjlfNDBkajJrN2hmNg&hl=en
Manejo de un proyecto de videojuego [PROGRAMA]: http://docs.google.com/Doc?docid=0ASN0P9xJIL_eZGdqZHJobjlfNDJjNTNnNmZkaw&hl=en

OGRE cambia su licencia

2009-09-17T15:34:00.000-07:00

Una pequeña nota informativa, OGRE3D, el (para mi) mejor motor de render 3d de código abierto que existe cambiará su licencia a partir de la versión que está actualmente en desarrollo, la versión 1.7 (aka "Cthugha"). De la 1.6 (versión actual estable) hacia anteriores versiones las licencias manejadas eran LGPL y OUL(OGRE unrestricted License), la primera es una licencia que permite realizar software comercial pero tiene ciertas restricciones en cuanto a su distribución, si el trabajo nuevo es un derivado del original con licencia LGPL, éste deberá ser libre también, en caso contrario su distribución será definida por el usuario creador. Para evitar problemas en distribución, generalmente se desarrolla software con linkeo dinámico de las libs, si se usa un linkeo estático, toca tener mucho cuidado del producto que está siendo "vendido" para no violar la licencia; la segunda era la licencia Comercial del motor, la cual te permitía realizar software comercial, cambios sobre el mismo engine y cosas similares sin necesidad de dar siquiera créditos, obviamente por un costo.

Bueno, para beneficio de toda la comunidad el motor pasa a tener una licencia MIT, la cual permite realizar software comercial sin importar en tipo de linkeo que se use, permite realizar cambios sobre las fuentes directas del motor y luego vender dichas fuentes sin problemas (como sacar tu propio Ogre3d comercial llamado donde solo le cambies algunas cosas), en general esta licencia es una de las mas "abiertas" del mundo del software libre y básicamente permite hacer lo que "SE TE DE LA GANA" con el software al que esta licencia acompaña.

La pregunta que salta a la vista es ¿y qué va a pasar con el esquema de licencia DUAL? ¿Qué va a pasar con la licencia OUL? Bueno en un pequeño FAQ publicado por Sinbad dan la respuesta: la licencia OUL saldrá de Ogre desde la versión 1.7 en adelante (hasta nuevo aviso claro está), de esta manera solo se tendrá una sola licencia, la MIT Licence y el esquema dual queda anulado.

Es de tener en cuenta que la licencia dual sigue funcionando para las versiones 1.6 y anteriores.

Este es el link a la noticia completa donde dan respuesta a algunas otras cuestiones respecto a este cambio de licencia: http://www.ogre3d.org/2009/09/15/ogre-will-switch-to-the-mit-license-from-1-7#more-685

Bye bye

Hola nuevamente

2009-08-29T16:39:00.000-07:00

Llevo ya bastante tiempo sin poner nuevo contenido, la verdad es que he estado full con el desarrollo de unos proyectos que espero culminar esta misma semana para retomar algunos desarrollos que tuve que parar.

En cuanto al blog, espero publicar algunos artículos sobre desarrollo de juegos en JME, el uso de GameStates, RenderStates y StandardGame, así como tutoriales sobre como crear pantallas de menú de juego en este motor con Swing (look propio), sistema de configuración de opciones del juego, controles en primera y tercera persona y cosas así. Pero todo esto será luego de entregar el proyecto de Colciencias esta semana.

Por ahora creo que pondré algo de "Mini Ninjas", es un juego de un look toon bastante bonito e interesante, no se mucho de su historia pero sus videos ingame son bastante buenos y además tienen a un estudio con grandes trabajos a sus espaldas: Io Interactive, los creadores Hitman y Kane & Lynch.

Dejo aca los videos de los protagonistas de esta interesante historia:

Futo:

Shun:

Tora:

Kunoichi:

Suzume:

Hiro:

SSAO en JME

2009-07-22T20:32:00.000-07:00

Luego de un tiempo de estancamiento seguido de mucho trabajo he logrado hacer que el Oclussion Mapping funcionara en este game engine para mi proyecto en Java, aún flata cuadrar algunos valores del shader pero creo que funciona bien. Dejo unas capturas:

[Con iluminación]

[Sin iluminación]

[Un pasillo en primera persona]

Una comparación desde el mismo ángulo, importante incluirla :D

[Sin SSAO]

[Con SSAO]

Bueno espero comentarios, yo personalmente prefiero con SSAO y buena iluminación :D. Aún hay que texturizar la ciudad y aplicar "tal vez" un normal map. Bye bye

Llamadas dinámicas en ActionScript 3.0

2009-07-21T17:26:00.000-07:00

Estoy haciendo una plataforma en flash (AS3) para crear mini-sites mas fácil para la empresa con la que estoy ahora, debido a esto he estado explorando patrones y otras cosas y he revisado las fuentes del Symfony y observé algo interesante:

Para poder hacer llamado de métodos en las acciones desde un template se usa

"link_to ('modulo/accion' );"

Esto se procesa en el controlador y llama dinámicamente a la clase y el método que se pone en el string de entrada en la función "link_to". Es uno de los pilares de este framework para hacer uso del patrón MVC, es totalmente práctico poder hacer algo como esto ya que permite realizar llamadas a métodos dinámicamente recibiendo el nombre desde archivos de configuración, bases de datos o cualquier otro tipo de entrada, incluso te permite hacer algo como:

var $metodo = $metodo_Configurado_En_El_Template;
if ( $error ) $metodo = "errorModulo";

call_method ( $metodo ); // Algo así es el nombre de la función en php que permite hacer este tipo de ejecuciones dinámicas.

Esto es el Core del asunto. Bueno pensando un rato y leyendo otro me pregunté si podría hacer algo similar en AS3 y luego de buscar un poco hice una prueba y esto es lo que encontré: (adelanto, SI SE PUEDE).

Para cargar una clase dinámicamente y crear una instancia hacemos:

var clase : Class = getDefinitionByName ( "myclase" );
var instancia : Object = new clase ();

Hasta aca no hay nada nuevo, es lo mismo que se usa para usar un movieclip con linkage desde las fuentes de código. Lo que descubrí es que en flash, los métodos y atributos públicos son almacenados en forma de un array asosiativo en una instancia de una clase, es decir, cuando yo creo "instancia", luego puedo llamar a sus métodos como si "instancia" fuera un array asosiativo y cada método o atributo es un dato dentro del array. Para acceder al dato el nombre que le demos al atributo o método es el "key" usado en el array para extraer su valor. Teniendo esto podemos hacer algo como esto:

prueba.as:
------------
package
{
public class Prueba
{
public function debug () : void
{
trace ( "es una prueba" );
}

public function release () : void
{
trace ( "versión final" );
}
}
}

main.as:
----------
package
{
public class Main
{
public function Main ()
{
var obj : Prueba = new Prueba (); // Instancia de la clase

// Trata al objeto "obj" como un array asosiativo y accedemos al campo con key="debug"
// Esto nos retorna un método que luego invocamos usando "()".
obj [ "debug" ] ();

// Podemos hacer algo como:
var metodo : String = "debug";

// ... código de lógica que hace cambiar la variable
// finalmente decidimos que método usar y lo llamamos:
obj [ metodo ] ();

// Esta lógica puede ser dada por una función tipo "link_to" usada en Symfony:
// link_to ( "modulo/metodo" );
var tmp : String = link_to.getRuta (); //retorna algo como "modulo/metodo"
var path : Array = tmp.split ( "/" ); // retorna un array asi: [0] => modulo, [1] => metodo

// el primer array retorna el nombre del método "metodo" y
// el segudo retorna su cuerpo y lo ejecuta, de esta manera tenemos un controlador y
// soporte para llamar multiples métodos internos a las clases dinámicamente.
obj [ path [ 1 ] ] ();
}
}
}

Bueno esto es todo lo que descubrí en mi búsqueda, espero sea de utilidad, cualquier duda dejarla y la contestaré. Por ahora yo usaré esto para terminar de implementar mi plataforma con llamadas dinámicas para hacerla flexible :P.

Game Engines Parte 2 [PushButton Engine]

2009-07-08T23:17:00.001-07:00

Algo nuevo en este mundillo tan interesante ha sido el PushButton Engine. Es un Game Engine en flash que está dando de que hablar, tanto que ya está en el roadmap del Zen para integración. Este engine es un motor construido en ActionScript 3.0 de Flash para la construcción de juegos sobre esta plataforma, hay que destacar que sus creadores son los muy reconocidos Garage Games (http://www.garagegames.com/), creadores también del famoso Torque Engine.

Dentro de las características del motor tenemos:

Tiene una arquitectura modular que permite decidir que partes del motor se van a utilizar
Permite integración de libs de terceros fácilmente (como en flash directo)
Manejador de recursos bastante bueno
Logger
Serialización
Timers
Motor de físicas 2D
Manejo de mapas con tiles (no se que tanto soporte aún pero creo que no tiene ni scrolling ni alturas).
Una lib de pathfinding (navegación)
Sistema de network con paso de eventos

En el roadmap (aunque como herramientas de costo) están un editor y un sistema de network mucho mas trabajado.

El motor ya tiene un juego en desarrollo sobre él de la misma casa, aca una captura, en la red se pueden ver videos preview del juego y se ve como bonito:

Listo por ahora, quedamos pendientes del Zen. bye bye

Game Engines Parte 1 [Ogre3D].

2009-06-30T23:02:00.000-07:00

Ha pasado tiempo y han salido muchas cosas nuevas así que solo pondré este pekeño (largo) post sobre 3 de ellas, las que mas me han impactado, todo esto es relacionado a video games y open source.

Ogre:
Excelente motor de render (lo digo a los 4 vientos) que tiene dentro de sus nuevas cosas 4 muy interesantes que resaltaré hoy:

Hydrax:

Es una lib para Ogre que te permite (básicamente) renderizar escenas con agua de manera sencilla y bonita (la calidad es bastante buena). Dentro de las características tenemos:

Efectos de refracción y reflexión bastante realistas
Efectos de profundidad basados en mapas de profundidad
Caústicas, efectos de sol, rayos de dios (god rays), espuma y soporte para Decals para pequeños efectos sobre el agua
Además incluye un "editor de agua" que está bastante bien logrado

En general el sistema es muy bueno, flexible y logra una gran calidad de visualización. Esto integrado a un sistema de físicas que maneje espacios - entornos (espacio exterior, aire, dentro del agua, etc.) es apenas para tener un bueno juego con escenas como las de crysis en la playa y demás.
Datos importantes:
Autor: Xavyiy
Foro oficial: http://www.ogre3d.org/addonforums/viewtopic.php?t=8391
Descripción: En el link encontrarán info mas detallada, links a videos y links al demo y las fuentes.

--
SkyX:
Del creador de "y tu mamá también" llega .... no mentiras. Esta es otra obra de arte del mismo "mancito" de Hydrax. El un sistema para crear cielos en Ogre mucho mas impactantes de lo que ya son actualmente. Como dice en el hilo del foro: SkyX prentende ser un rápido, sencillo y FOTOREALISTA simulador de cielos.

Características:

Manejo de información atmosférica
Nubes volumétricas WOW y basadas en capas (Caelum solo soporta la última técnica creo*).
Sol y luna con ubicación en el espacio y modificación de toda la escena según esta información
Soporte de HDR
Integración con Hydrax (en proceso)
Efectos como lluvia (nose que otros tenga ya listos :P)
Es posible que sea separado en dos partes: SkyX que tendría todo lo relacionado con el sistema de "cielo" y otro que sería el sistema de nubes volumétricas, esto con el objetivo de que el último se pueda integrar fácilmente a cualquier sistema de "cielo" como Caelum.

Datos importantes:
Autor: Xavyiy
Foro oficial: http://www.ogre3d.org/forums/viewtopic.php?f=11&t=48414
Descripción: En el link encontrarán info mas detallada, links a videos y en la página 4 encontrarán un link al demo, las fuentes serán liberadas en Agosto según el creador.

Estos dos son creados por el mismo personaje y ya muchos le han propuesto que los fusione y cree algo como "NatureX" jejeje buena idea aunque me gusta mas el pensar del creador quien incluso piensa en desacoplar el SkyX en dos partes para que puedan ser utilizadas en otros sistemas de manejo de entorno (cielo).

Bueno esto es solo parte del paquete, si a esto le sumamos lo que viene ya tenemos algo de un 80% de integración completa para crea juegos en entornos abiertos, solo faltaría algo como "SpeedTree OpenSource" y listo lo tendríamos todo (respecto a esto, conozco otro plugin para Ogre llamado Nature que integra Hydrax + Caelum + Terrenos Extensos + generador de árboles y pasto, el sistema es bueno pero le falta mucho trabajo aún, luego pongo un link)

--
Nuevo manejador de terrenos:
Tan simple como lo dice el título: Sinbad (para quienes no saben es el creador de Ogre - bueno su nick) ha estado trabajando full time en un nuevo manejador de terrenos totalmente mejorado que tiene dentro de sus características mas destacables:

Soporte para edición de terreno InGame, esto ya estaba utilizando un plugin externo a Ogre.
Soporte para paginación con carga en fondo, también estaba en un plugin externo, uno de los mas antiguos de Ogre según se.
Soporte para generar mapas de normales y luces en fondo en un hilo independiente (UN HILO INDEPENDIENTE :D)

En general algo muy deseado por todos los que usamos este excelente render engine, solo espero la hora de que llegue el gran cambio a la siguiente versión de Ogre.

Datos importantes:
Autor: Sinbad (Creador de Ogre)
Foro oficial: http://www.ogre3d.org/forums/viewtopic.php?f=11&t=50674
Descripción: En el link encontrarán info mas detallada, aún no hay descargable ni nada pero si entras por el subversión podrás bajar este nuevo sistema de terrenos (desde las fuentes).

--
Finalmente tenemos otro gran avance en la comunidad de Ogre:

Navi & Awesomium:
Primero tenemos a NaviLib, una biblioteca exclusiva para Ogre que permite integrar e interactuar contenido WEB con la escena 3D (usando materiales o overlays). Esto no solo te permite utilizarla para crear GUI 3D rápidamente (se hace en html o incluso en flash ya que integra bien el soporte de flash) sino que también puedes escribir código en JS que interactue con la escena 3d y código en C++ (dentro del programa usando Ogre) que interactué con el código JS. La gran apuesta de este proyecto creo que es la integración entre lo web y los videojuegos y creo que le atinaron.

Por el otro lado está Awesomium, básicamente es una lib que te permite integrar contenido Web a una aplicación 3D en Ogre. Dentro de sus usos está la posibilidad de hacer gráficos para la web que sean parte de la escena 3d y comercio (utilizando la web dentro de la aplicacion).

Datos importantes:
Autor: ajs15822
Foro oficial: http://princeofcode.com/navilibrary.php
Descripción: En el link encontrarán todo, info + fuentes + demos + videos + documentación, a decir verdad es uno de los proyectos mas completos que conocí en arque

No tengo fotos pero si este video, recomiendo su vista hasta el final. Bye

---
Bueno la verdad me extendí un poco mas de lo que esperaba así que hoy dejaré ahí, en la lista está hablar de otros proyectos como Zen y Push Button Engine, esas dos partes del post serán ya mañana. bye bye.

Próximo: Game Engines Parte 2 [Push Button Engine]
Próximo: Game Engines Parte 3 [Zen Engine]

Bueno nos vemos mañana. bye bye

Tribungo Wave

2009-06-18T14:42:00.000-07:00

Dada la nueva moda que se está despertando con Google y Google Wave se me ha ocurrido mi propia versión del WAVE a la que llamo Tribungo Wave (provisionalmente) jejejeje, la idea es una aplicación web orientada a desarrolladores que centre todo lo necesario en un solo site (tu Wave) delegando el trabajo de server y back-end a otros sistemas como GMail, Youtube, NoteBook, Calendar, Web Picasa, etc., adicional a esto el sistema si tendrá en back-end solo un pequeño sistema para dar soporte a directorios "virtuales" y settings que añadan varios niveles de seguridad (lo que no tenemos en google).

Las plataformas que he elegido para desarrollar este pequeño proyecto son:

GWT (Google Web Toolkit)
Php (tal vez Symfony dependiendo de la carga real del back-end)
Toda la GData y las API's de los servicios de Google.

Los servicios con los cuales iniciaré son:

GMail *
GTalk (y MSN, es muy usado aún) *
Calendar **
Blogger **
Youtube ***
Web Picasa ***
Note Book de Google ****
Buscadores Google y Yahoo (genéricos) ****
Buscadores de midia Youtube (videos) por ahora solo este :P *****
RSS *

Una pantalla de como se vería:

[Imagen construida en Paint]

Un futuro no tan distante

2009-06-12T15:44:00.000-07:00

Los vi hace poco, uno en el CNEIS y el otro hoy en uPlay y pensé en compartirlos, es una visión futurista, la primera es algo que ya está al alcance de la tecnología de hoy (mas no de la economía) y la segunda si es un poco mas distante en todos los sentidos .... por ahora ...

Formatos MESH y SKELETON de diversas versiones de Ogre

2009-06-06T17:32:00.000-07:00

Estoy en este momento terminando una aplicación con realidad aumentada en Ogre, ya la tengo funcionando aunque me falta acomodar varias cosas que espero tenerlas listas mañana. El punto es que el contenido se hizo en 3 Studio Max 2009 y se exportó a la ultima versión de Ogre [1.6] la cual utiliza el formato MESH 1.4. Bueno hasta aca todo bien, probamos el contenido con un visualizador de Ogre y todo funcionaba bien, modelo, materiales, texturas y animaciones bien. La aplicación luego de pelear casi una semana con ella (pues tenía también otras entregas en la empresa) por fin funcionó completa hoy (sábado) y todos contentos; comencé la integración y pues resulta que en la aplicación yo estoy usando la versión 1.2.4 de Ogre (del 2007) que implementa el formato MESH versión 1.3 (o 1.2, no recuerdo bien cual de los dos es realmente :P) y pues obviamente el contenido no se cargaba ..... :'(.

Solución:
La encontré en este hilo del foro de Ogre: http://www.ogre3d.org/forums/viewtopic.php?f=8&t=49004. Básicamente lo que hay que hacer es tener los OgreXMLConverter de ambas versiones de Ogre (1.2.4 y 1.6) y hacer esto:

Utilizar el converter de la versión 1.6 y convertir el MESH y SKELETO a XML (Mesh -> XML & Skeleto -> XML)
Copiar los dos XML's al directorio donde tengas el converter de la versión mas vieja del Ogre, en mi caso el 1.2.4 y convertirlos hacia los formatos binarios (XML_mesh -> Mesh & XML_skeleto -> Skeleto)

Con estos dos sencillos pasos pude realizar las conversiones y solucionar el problema de los assets que tenia para la aplicación.

Jjejejejeje y justo entro al site de Ogre a bajar los OgreXMLConverter binarios y sourceforge estaba abajo ¬¬ afortunadamente siempre cargo conmigo una copia de las fuentes de Ogre versión 1.6 y otra mas antigua, casualmente era la 1.2.4 así que solo tuve que compilar ambos proyectos para generar los ejecutables y VIOLA¡¡¡¡¡

Al igual que el autor del post en Ingles, espero que esta info les sea de utilidad.

Oferta laboral - desarrollo de videojuegos

2009-06-06T11:06:00.000-07:00

Un amigo me pidió que hiciera público este afiche de convocatoria para gente que quiera hacer games, en el afiche se ve toda la info y el mail al que tienen que escribir y por ahora es toda la info que tengo. Cualquier cosa iré actualizando. [La convocatoria creo que es solo para Colombia pero igual no se pierde nada enviando la info aunque seas de otro país]

E3 para esta semana

2009-05-30T08:55:00.000-07:00

Iniciará el E3 esta semana y la mayoría de las empresas ya han revelado muchas de sus cartas, lo que mostrarán y lo que no. En general parece que el evento estará lleno de cosas grandes aunque aún hay varias que personalmente me gustaría ver pero que no han sido ni mensionadas siquiera :'(.

Lo que me gustaría oir en el E3:

Anuncio de un port para compatibles de Halo 3
Anuncio de un port para compatibles de Fable 2
Mas info sobre juegos como Borderlands y que Intel muestre *POR FIN* algo de "Project Offset"
Anuncio de nuevas características del UE3 y algún otro Engine que se cuele (me suena el Id Tech 5)
Mas info sobre RAGE (el juego de idSoftware)

Por ahora creo que con eso me conformaría bastante :D pero bueno, será esperar a ver que sucede. Igual cualquier noticia extraordinaria trataré de publicarla por este medio.

Limitación del Hard de 32 bits

2009-05-30T08:31:00.000-07:00

Bueno sencillo, ayer iba todo contento a instalar mi nueva RAM y cuando inicio veo que solo me reconocia 3.2G apróx. Vaya sorpresa, yo compré 4G y la placa madre si las reconoce (tenemos pins extras) pero el O.S. no mmmmm, bueno hoy que tengo internet de nuevo busco un poco en internet y cuando veo la raíz del problema recuerdo mis clases de arquitectura de hardware :S. La cosa es simple, un O.S. de 32bits no logra direccionar 4G de RAM o bueno, si lo logra, pero esta es compartida con la RAM del Video y demás así que si tengo casi 900M en Video, es evidente que no podré utilizar todos los 4G de RAM que he instalado :S.

Soluciones:

Cambiarme a un O.S. de 64 bits (no me gusta esta opción todavía, creo que esperaré un año mas para hacerlo)
Activar PAE en el arranque de Windows (boot.ini) para que el kernel me reconozca las 4G que tengo de memoria: esta sería buena opción pero dado que tengo tanto hard y tanto soft, es posible que muchos dejen de funcionar por problemas de compatibilidad (no todos son certificados micro$) así que tampoco.
Quedarme con las 3.2G que reconoce por un tiempo mientras me siento totalmente seguro para pasarme a un sistema de 64bits. Está será la opción elegida por ahora :D.

Un documento que explica un poco mejor este limitante es: http://www.multingles.net/docs/jmt/4gbmem.htm, lectura recomendada por cultura general.

Actualización de máquina

2009-05-29T14:29:00.000-07:00

Por fín, llegó la hora de trabajar con un PC decente, hoy compré las dos ultimas partes necesarias para mi computador, quedó básicamente con:

Video: nVidio GTX 260 TOP, 896M de memoria, DDR3, PCI Express 2.0

4G de RAM, OCZ Reaper HPC PC2 8500 (similar a la de la foto pero no es la misma)

1.5 Teras en Disco (3 de 500G).
Procesador de 64Bits 6000+ a 3.0G AMD ATHLON XP
Fuente de 650W Termaltech
Dos pantallas LCS LG (creo jajajaja) WideScreen de 19' o 21', no estoy seguro :P.
UPS que me da como 30 minutos de soporte de energia con el PC actual
Torre extra grande (servidor) pero no me se la marca

Y ya está, apenas para jugar un rato :P y trabajar otro rato.

Hablando de trabajo, he compilado el Zen Engine y debo decir que de todos los proyectos que he trabajado y que he tenido que leer y demás, este es el mejor. Fue un verdadero gusto para mi compilar este proyecto, todo es absolutamente entendible y claro, muy bien organizado y estructurado, obviamente se me presentaron problemas como en todo (menos en Ogre que compila de una :P), pero los problemas eran cuestiones menores y fácilmente solucionables. Felicitaciones al equipo de Indie Zen por este desarrollo, pronto estaré liberando algunas cosas funcionando sobre este proyecto.

Pronto pondré en este blog como poner a funcionar el Zen para referencia de otros.

Un sitio que todos queremos

2009-05-27T16:19:00.000-07:00

Yo soy fiel seguidor del sitio http://www.3djuegos.com y he visto hoy (con mucha sorpresa y agrado) que han sacado una aplicación web para quienes como yo mantenemos al tanto de las noticias de este mundillo.

La aplicación no es algo de otro mundo, pero lo que realmente me gustó es la posibilidad de tener en una lista mis juegos favoritos (categorizados) y poder recibir en mi panel personal las noticias sobre estos juegos en particular (no tener que buscarlos en el home y por todo el site), esta herramienta es algo increiblemente útil y me parece un HIT para los creadores del portal. Felicitaciones a la gente de 3D Juegos por su nueva plataforma para la comunidad. Muy Recomendada.

Juegos AAA - Game Engines Next-Gen

2009-05-18T20:59:00.000-07:00

Es una pequeña lista que tengo de los juegos mas destacados en la última temporada y los respectivos engines en los cuales fueron realizados.

Nota: No tiene el orden que deseaba darle, pero si no lo publico ahora creo que no lo publicaré nunca jejeje, ademas estoy retomando actividades (por fin :P).

Nota: Actualizaré la lista tan pronto como pueda ya que ando con proyectos hasta el cuello.

Video Juego	Unreal Engine 3	GameBryo	CryEngine 2	Propietario
Mirror's Edge
Assassin's Creed				scimitar
Gears of War (1&2)
Crysis
BioShock
Unreal Tournament 3
Army of Two
GTA 4				RAGE
STALKER Clear Sky				X-ray Engine 1.5
Halo 3				Halo Engine
Dead Space				Godfather game engine
Prince of Persia				scimitar
Project Origin
Resistance 2				Insomniac Engine v.2.0
Far Cry 2				Dunia
Resident Evil 5				MT Framework
Rage
Fallout 3
God of War 2				Kinetica
God of War 3
Ninja Gaiden 2
End War
Borderlands
Prototype				Titanium Engine
Bionic Commando				Diesel Engine
FrontLines Fuel War
Call of Duty				Call of Duty 4 engine
TimeShift				Saber3D Engine
Mass Effect
Lost Planet				MT Framework
Final Fantasy XIII
The Last Remnant
Hawx
Cryostasis				AtmosFear 2.0
Necrovision				PAIN Engine
Killzone 2				Deferred Rendering engine
red raction guerrilla				Geo-Mod 2.0
Turok 2008
X-Blades
Dark Sector				Evolution Engine
Stormrise
Dark Void
Singularity

News News [2]

2009-04-15T22:24:00.000-07:00

Bueno hay bastante información nueva para nosotros y la mayoría bastante agradable.

--
Los Slides y Videos presentados por nVidia en el GDC'09 están actualmente disponibles para ser descargados y vistos (o leidos) totalmente gratis en la página oficial del gigante.

Links directos:
NVIDIA APEX: From Mirror's Edge to Pervasive Cinematic Destruction to Real-Time Fluid Simulation
video | slides

The In and Out: Making Games Play Right with 3D Stereoscopic Technologies
video | slides

CUDA and Multi-Core Gaming: Lessons from the Trenches
videos | slides | Wite paper | slide deck videos | supplemental videos

NVIDIA APEX: High-Definition Physics with Clothing and Vegetation
videos | slides

Platform-independent Shader Development with mental mill: The Making of Dead Rising 2
videos | slides

Math/Physics for Programmers
Search for the presentation video here

Advanced Visual Effects with Direct3D for PC
D3D11 tessellation | D3D10/11 special effects

Khronos Developer University
OpenGL3.0/3.1 overview | Introduction to OpenCL

No he tenido la oportunidad de leer alguno pues apenas me estoy enterando por medio de "gamedev.net", espero porder leer algunos y comentar al respecto. Igual creo que son un recurso importante.

--
Otra noticia importante de la cual apenas logro enterarme hoy es que RakNet ahora es "gratis" para desarrollos independientes WOW. Para los que no saben RakNet es una biblioteca bastante interesante (y usada) sobre comunicación en red para juegos, es multiplataforma, soporta operaciones no bloqueantes, manejo de sesiones, usuarios, llamadas a métodos remotos, soporte para audio [voz] y otras cuantas características que son bien interesantes.

RakNet es utilizada en la industria por engines como Unity. El que sea "gratis" tiene algunas restricciones como logos y cosas así muy simples. Lo realmente importante es que restringen el método de distribución de la aplicación a "descargable por internet" para PC, pero bueno algo es algo señores.

Link: http://www.jenkinssoftware.com/purchase.html

--
Otra noticia importante para developers que están trabajando con XNA es que ha salido un Physics Engine (motor de físicas) llamado Matali. Este engine permite realizar proyectos sobre XNA y generar ejecutables para Windows 32/64bits y XBox 360. Yo no utilizo XNA por que creo que está bastante lejos de ser un Game Engine que realmente me permita enfocarme en el desarrollo de un video juego en lugar de la plataforma que lo va a soportar, pero es claro para mi que este proyecto acerca un poco mas la plataforma XNA a este objetivo.

Para quienes utilicen XNA o deseen experimentar les recomiendo este desarrollo, hay que seguirle la pista de cerca señores, creo que no será Open Source pero igual tenemos que estar pendientes :P.

--
Esto es todo por ahora, pronto publicaré noticias mas locales.

Open Source Game Engines

2009-04-13T09:24:00.000-07:00

Debería estar en bogotá pero desgraciadamente no pude conseguir tiquetes para viajar así que viajaré hoy.

Mientras eso pasa sigo trabajando y leyendo algo de noticias y me he topado con una que da pie a este Post: Motores de video juegos de código abierto.

Aunque no voy a profundizar mucho sobre el tema, solo deseo decir que estoy siguiendo bastante de cerca los desarrollos de dos proyectos bastante prometedores en este aspecto que son:

--
ZOSS: Zen Open Source Software (Zen Game Engine)

Este es un game engine que surgió hace ya unos meses, lo descubrí en los foros de Ogre y ya he tenido la oportunidad de discutir algunas cosas con su lider Tony Richards. Usa una arquitectura bastante interesante, su código es absolutamente claro y legible (por lo menos la versión que te puedes bajar), tiene un sistema basado en Plugins (similar al que definí para Baphomet hace ya como un año, esto fue algo que me llamó bastante la atención) sencillo de utilizar que hace que el motor sea totalmente flexible. En render hace uso de Ogre como plugin, pero puedes cambiarlo. Ya integra Hydrax y Caelum, también el manejador de escena basado en portales de Ogre y otras características interesantes e importantes.

Tiene un CORE bastante interesante y bien diseñado (y pensado) que ya maneja hilos, memoria, sistema de plugins, etc., Esta es una de las partes que mas me gustán ya que está totalmente independiente del motor, es un framework que puedes utilizar en cualquier proyecto, no solo juegos sino cualquier tipo de desarrollo en C++ que necesite ser de fácil extensión, flexible y que haga uso de tecnología multi-hilo.

En general recomiendo mucho "seguirle el paso" a este motor ya que para mi promete bastante y será mi principal propuesta en Sui - Generis.

Link: http://www.indiezen.org/

--
Xreal

De este motor solo me enteré en esta semana y apenas hoy lo estoy bajando. No es mucho lo que se de él. Entre sus puntos interesantes está que es un port del Id Tech 3 (reescrito totalmente según leo), que su render está mucho mas trabajado, que tiene soporte para HDR, sombras suaves (soft-shadows). Carga contenido de quake y doom y del ultimo Unreal Tournament (3). Adicional a esto su principal desarrollador está trabajando en una Suit de herramientas para Blender3D que permitan desarrollar un juego sobre herramientas OpenSource (esto me suena conocido), de esta forma piensa poder eludir el uso de herramientas propietarias como Maya o Max (esto también me suena familiar jejeje).

Este según he leido en su web oficial, será un game engine para FPS's exclusivamente. (como su proyecto padre)

Link:http://www.xreal-project.net/

--
Otros dos proyectos similares que trato de seguir aunque no tan de cerca son:

The Zombie Engine: Es un game engine basado en Nebula Device 3 que ya tiene un juego comercial sobre él (creo) Link: http://thezombieengine.sourceforge.net/, Link interesante: http://thezombieengine.sourceforge.net/?page_id=22.

The Nebula Device 3: Es un clásico, hace mucho tiempo estaba por encima de Ogre en cuanto a render siendo un engine mas cercano a un "game engine", luego dejó de ser tan bueno (ND2) pero ha sido retomado y su versión 3 está bastante interesante. Link: http://nebuladevice.cubik.org/

--
Esto es todo, estoy en planes de ponerme en contacto con el desarrollador de Xreal para saber que está haciendo sobre Blender3D y ver que se puede lograr en conjunto.

Alquimista reload

2009-04-06T13:09:00.001-07:00

También hemos retomado nuestro viejo pero prometedor proyecto llamado Alquimista. Inicialmente este era un juego de cartas tipo Yu Gi Oh o Magic, pero lo estamos extendiendo a un mundo online isométrico.

Por ahora estamos trabajando en la implementación del game y el diseño de los nuevos personajes, aca dejo una captura de lo nuevo:

Esperamos poder abrir la beta tester pronto, cualquier novedad sobre el asunto será publicada por este medio (mientras sale el website :P).

Sui - Generis: algo grande

2009-04-06T11:35:00.000-07:00

Bueno ya retomando un poco actividades normales del diario vivir. Como resultado del evento CNEIS donde fui conferencista (no me fue bufff en la conferencia pero bueno, creo que se logró el objetivo) he tenido oportunidad de hablar e intercambiar algunas ideas con varias personas del medio en mi pais (Colombia) y pues me ha surgido la idea de realizar un proyecto:

Construcción de una Suite de desarrollo de video juegos partiendo de software libre.

Y con "Suite" no me refiero solo a un game engine, ya que este proceso no está limitado a esta herramienta sino que por el contrario implica muchas otras como herramientas para manipulación de imágen, modelado, sonido y video entre otras.

Obviamente soy conciente de que es algo super grande, complejo y dificil y pues no estoy en capacidad de desarrollar algo tan ambicioso yo solo. Por este motivo he decidido hacerlo público:

Idea del proyecto:
Suite para desarrollo de video juegos basado en software libre

Nombre del proyecto:
Sui - Generis

Justificación:

La idea salió de oir a uno de los expocitores del CNEIS llamado Oscar Andrade líder del LOOP - Colombia (si está mal escrito me corrigen por favor).

Un videojuego en U.S.A. cuesta unos 50$ dólares lo que vendría siendo unos $50.000 pesos colombianos si la conversión no la hacemos con la tasa de cambio sino contra "poder adquisitivo" y claro, todos comprariamos software (juegos incluidos) legalmente si las cosas fueran así, pero en la realidad la conversión se hace contra la tasa (ose que tienes que pagar casi 3 veces el valor mensionado = $150.000) por videojuego. Lo mismo pasa con el software utilizado para creación de juegos (2d o 3d), sus costos son muy elevados para los latinos. A tal punto llega lo absurdo del asunto que un estudio latino de juegos o animación puede terminar pagando mas en infraestructura (soft + hard) que en mano de obra (software licenciado claro).

En LatinoAmérica existen muchos desarrolladores expertos en programación, diseño, ilustración, modelado, sonido, etc., al punto de ser contratados en el extranjero por otros estudios desarrolladores. También existen una gran cantidad de estudios independientes que están dandose "la pela" tratando de sacar su proyecto adelante con las herramientas que pueden usar que ya dejan bastante que desear.

En este orden, el software libre ofrece una gran posibilidad a todos ellos permitiendoles desarrollar contenido y juegos completos sin sobrecostos de software (los de hardware son imposibles de saltar), herramientas como Blender, GIMP, Ogre3D, Audacity, Cinelerra, jahshaka, etc., son ideales pero desconocidas y poco utilizadas. Las limitantes de estas herramientas en la mayoría de los casos no están en la parte técnica sino en el desconocimiento, APARENTE complejidad de uso y poca difusión (publicidad que pagan los grandes comerciales).

Todo esto sumado a las ganas y talento latino me llevan a pensar en trabajar en un proyecto que hasta ahora no existe, que permita integrar en una sola "Suite" todo esto. Mismas interfaces (que tengan una línea), personalización de las herramientas existentes, interfaces en español, documentación en español, unificación de su uso (mandos de teclado + mouse + interface), integración de formatos y un flujo de trabajo claramente definido es lo que se propone en esta idea.

El nombre sale de Sui - Generis, creo que no es necesaria mas justificación.

Todo está en español (incluyendo el nombre - o latín) para ser concecuentes con la idea global.

Qué sigue:
Por ahora la idea era ponerlo público para que ustedes opinaran al respecto, como lo ven, que creen? soy un loco o un soñador? es algo imposible? les parece interesante y podrían ayudar?

La idea inicial es generar alguna polémica al respecto para ver que tal está la cosa y si es demasiado descabellado o si tiene algo de sentido, luego de eso veré como se mueve la cosa y realizaré otra publicación sobre el tema.

Si alguien desea hacerme un comentario mas personal pueden hacerlo utilizando mi mail como medio (valtovar at gmail dot com).

Mientras estos días pasan revisaré el software disponible para evaluar pros y contras y haré publica la matriz de evaluación.

Notas finales:
Bueno como nota final pido si alguien puede ayudarme enviandome sus opiniones sobre los programas de código abierto que existen para tenerlas en cuenta en la evaluación. Los programas sobre los cuales fijaré mis ojos inicialmente son:

Blender 3D: Modelado 3D, animación y esculpido
Equivalente comercial: ZBrush y 3DMax
URL: http://www.blender.org/

GIMP: Edición de imagen
Equivalente comercial: Photoshop
URL: http://www.gimp.org/

Ubuntu Studio: Sistema Operativo especializado en midia
Equivalente comercial: Windows
URL: http://ubuntustudio.org/

Audacity: Edición de sonido
Equivalente comercial: SoundBooth
URL: http://audacity.sourceforge.net/

Jahshaka: Edición de video
Equivalente comercial: After - Premier ... creo
URL: http://jahshaka.org/

Ogre 3D: Motor de gráficos
Equivalente comercial: módulo render de un game engine
URL: http://www.ogre3d.org/

Bullet: Motor de físicas
Equivalente comercial: módulo de físicas de un game engine [nVidia Physx]
URL: http://www.bulletphysics.com/

OpenAl Soft: Motor de sonido
Equivalente comercial: módulo de sonido de un game engine [FMod - Irrlank]
URL: http://kcat.strangesoft.net/openal.html

No es mas por ahora.

Edit: El proyecto así como está planteado es bastante grande, cual es mi idea de ponerlo así en este medio:

1. Que la gente opine en el mismo medio
2. Comentarios que contesten preguntas como:

¿Por donde se debería iniciar?
¿Qué software serían los iniciales?
¿Qué área de la fase de pre-producción se debe trabajar primero?

3. Luego de tener algo de idea sobre estas preguntas voy a acotar mas el proyecto (dividirlo en fases) y pos ahí se mira como se atacan poco a poco.

Edit2: Algo simple, en lugar de evaluar herramientas independientes para el game engine como Ogre para render o AGEIA para físicas, propongo utilizar Zen Engine (http://www.indiezen.org/) lo considero mas enfocado a lo que se busca y ya hace uso de estos componentes como plugins.

News News

2009-04-02T21:55:00.000-07:00

Dos noticias que dan gusto, la primera es referente a Crytek: la empresa Alemana dió a conocer la nueva versión de su game engine: CryEngine 3, el cual ya corre sobre consolas XBox360 y PS3. Aunque aún no alcanza el nivel mostrado por el CryEngine 2 sobre compatibles, está claro que esta empresa desea hacerse con el liderazgo en el desarrollo de motores para video juegos.

Un video demostrativo:

Ahora veamos 3 videos bastante completos que nos ilustran muchas de las características técnicas de este fantastico game engine (versión 2):

[Video 1]

[Video 2]

[Video 3]

En este punto solo queda mostrar un acabado del engine a full calidad:

--

La segunda noticia tiene que ver con el motor Unreal Engine 3: en el GDC la gente de Epic ha revelado las nuevas características de su motor de juegos incluyendo un video demostrativo. Creo que es importante mensionar que se está trabajando en herramientas basadas en el Unreal Engine 3 para que el desarrollo de juegos OnLine (MMO) sea mucho mas sencillo, a esta nueva tecnología se le conoce con el nombre de "Atlas" y está siendo desarrollada por el grupo de Epic - China. Para ampliar esta noticia recomiendo la lectura de estos dos links

Para hacernos una idea mas clara veamos: (una imagen vale mas que mil palabras)

Video comparativo entre CryEngine y Unreal Engine

Video comparativo entre Crysis (CryEngine2) y Far Cry 2 (Dunia)

Esto sumado a al resurgimiento de Project Offset da un muy buen aire a la industria y a su desarrollo, lo único que falta es que estas herramientas estén al alcance de los desarrolladores independientes que abundan jejeje, esperemos que ya están cerca dos opciones que serán bastante buenas, info mas adelante.

Nos vemos en otra entrega.

Project Offset

2009-03-30T09:05:00.000-07:00

Este trabajo fue una de las cosas que mas me impresionaron hace ya como 3 años aca en Cali cuando aún Immersión estaba en Parquesoft, es definitivamente algo impresionante aunque habia estado muy apagado el ultimo año.

Bueno luego de mucho tiempo han actualizado su website oficial y he encontrado estos videos que considero de gran importancia y los dejo aca para deleite de todos:

Editor:

Entornos destruibles:

Creando estructuras:

Shaders:

Viejos recuerdos

2009-03-24T17:45:00.000-07:00

Estas son dos imagenes que me recuerdan tiempos de universidad jejejeje me gustaba bastante este tema, divina la primera:

Algo de música

2009-03-24T17:06:00.000-07:00

Bueno no todo es trabajo jejeje así que aca dejo algunos de los videos que mas me gustan en cuanto a música se refiere:

Within Temptation - Ice Queen

Within Temptation - Angels

Within Temptation - Memories

Within Temptation - Mother Earth

Nightwish - Amaranth

Disturbed - Stricken

Therion - Son of the Sun

Yo se que estos grupos tienen otras propuestas pero estas son las que mas me gustan :P.

Bye

PaperVision3D + Jiglib Physics Engine

2009-03-19T17:23:00.000-07:00

He estado trabajando en algunas cosas de realidad aumentada, 3d en flash y 3d con físicas en flash y pues voy a explicar un poco como se trabaja con estas dos API's en flash para tener un render + físicas en flash. Hay que tener presente que flash aún tiene trabajo por delante en este campo y dentro de sus limitantes está la velocidad de ejecución que es bastante decente para ser flash y la simulación que pongo en la demo pero que aún no alcanza un game engine escrito en C++ o Java (con nativos, por que JAVA3D está incluso por debajo de PV3D).

Bueno iniciamos con el trabajo en AS:

Lo primero es bajar tanto el PaperVision3D como el Jiglib, links:
PaperVision3D: http://code.google.com/p/papervision3d/downloads/list
Jiglib: http://code.google.com/p/jiglibflash/downloads/list

Las pones en tu directorio así:
Proyecto/lib/
org/ -----------> papervision3d
jiglib/ --------> Jiglib

Importar las libs y ahora si el código:

NOTA: pido disculpas, yo se que sería mucho mejor si pusiera mi código en un "pre" o algo así pero es que ya lo he intentado como 4 veces y esta PUTA mierda me lo daña siempre entonces pues no veo otra manera de ponerlo mas que esta:

package
{
import flash.display.DisplayObject;
import flash.display.Sprite;
import flash.display.Bitmap;
import flash.events.Event;
import flash.events.*;
import flash.display.BitmapData;
import fl.controls.TextArea;

// PaperVision3D import
import org.papervision3d.scenes.Scene3D;
import org.papervision3d.cameras.Camera3D;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.materials.BitmapWireframeMaterial;
import org.papervision3d.materials.BitmapAssetMaterial;
import org.papervision3d.materials.BitmapMaterial;
import org.papervision3d.view.BasicView;
import org.papervision3d.cameras.CameraType;
import org.papervision3d.objects.DisplayObject3D;
import org.papervision3d.objects.primitives.Cube;
import org.papervision3d.objects.primitives.Plane;
import org.papervision3d.materials.utils.MaterialsList;
import org.papervision3d.materials.ColorMaterial;
import org.papervision3d.materials.BitmapAssetMaterial;
import org.papervision3d.core.math.*;

// Jiglib imports
import jiglib.math.*;
import jiglib.geometry.*;
import jiglib.physics.*;
import jiglib.physics.constraint.*;

// Esta clase es una clase base de PaperVision3D que te crea todo.
// "BasicView"
public class PoC extends BasicView
{
private var mController : FirstPersonController = null;

public function PoC ()
{
// Parámetros de configuración inicial.
super ( 1, 1, true, true, CameraType.FREE );

// No he visto hasta ahora un controlador en
// PaperVision3D ya listo para usar así que diseñé
// el mio propio.
// Cuando lo tenga mejor diseñado lo libero.
mController = new FirstPersonController ( _camera, stage );

// Crea el piso
createPlane ();

// Crea las 15 cajas 3D
createScene ();

// Este método hay que llamarlo, es el que
// inicializa el hilo principal de la aplicación.
startRendering ();
}

public function createPlane () : void
{
// Material en PaperVision3D (alambre)
var tmpMaterial : BitmapWireframeMaterial = new BitmapWireframeMaterial ();

// Creo el plano gráfico, le defino las dimensiones
// y en cuantos triángulos dividirlo.
var tmpPv3DPlane : Plane = new Plane ( tmpMaterial, 1500, 1500, 5, 5 );

// Lo añadimos a la escena principal que ya está creada
scene.addChild ( tmpPv3DPlane );

// El plano físico, recibe como entrada su representación gráfica
var plane:JPlane = new JPlane(tmpPv3DPlane);

// Se ubica en el origen y lo roto 85 grados respecto al eje X
// y lo añado al motor de físicas.
plane.MoveTo(new JNumber3D(0, 0, 0), JMatrix3D.rotationX(1.39));
PhysicsSystem.getInstance().AddBody(plane);
}

public function createScene () : void
{
// Define el material para las cajas (también alambre)
var tmpMaterial : BitmapWireframeMaterial = new BitmapWireframeMaterial ();

// Esto es un arreglo asociativo para mapear la caja, soporta:
// front, back, top, left, right, bottom y all.
var ml : MaterialsList = new MaterialsList ();
ml.addMaterial ( tmpMaterial, "all" );

// Desplazamiento en X para que las cajas salgan centradas.
var offset : Number = 400;
for ( var i : Number = 0; i < 15; i++ )
{
for ( var j : Number = 0; j < 15; j++ )
{
// Creamos la caja gráfica y la añadimos a la escena en pv3d
var cube : Cube = new Cube ( ml, 100, 50, 120, 5, 5, 5 );
cube.x = i*80;
scene.addChild ( cube );

// Creamos la caja física, recibe como entrada la caja
// gráfica y las dimensiones
var jcube : JBox = new JBox(cube, true, 100, 50, 120 );
jcube.MoveTo ( new JNumber3D ( (i*200)-offset, 50, j*70 ), JMatrix3D.IDENTITY );

// Luego la añadimos a la escena física
PhysicsSystem.getInstance().AddBody(jcube);
offset -= 60;
}
offset = 400;
}
}

// Esto hay que hacerlo, es el método que será llamado por papervision3d
// en cada frame de la ejecucion del programa, aca se actualiza toda la
// escena gráfica y física.
override protected function onRenderTick ( event : Event = null ) : void
{
PhysicsSystem.getInstance().Integrate(0.2);
super.onRenderTick ( event );
}
}
}

Como ven la integración es muy sencilla, el motor de físicas está bien diseñado y la verdad me gusta bastante ya que es el unico que es 3d de verdad, APE es 2D, WOW es supuesto 3D pero realmente solo maneja coordenadas en 3D (x,y,Z) pero no soporta rotaciones sobre los objetos (entre otras cosas), así que mas bien es un 2.5D y queda este que si es 3D completo :D.

Esto se compila y se obtiene algo similar a esto, yo se que lo ideal sería poner el swf pero no encontré como hacerlo en blogger :S, lo que dicen es que lo suba a un host y luego ponga el código en html para embeberlo pero no tengo host para subirlo entonces pues jodidos :S, así que por ahora capturas:

Manejo de memoria en C++: Smart Pointers [1]

2009-02-22T13:16:00.001-08:00

Esta entrada pertenece a una serie de entradas que voy a publicar sobre C++ y algunas cosas de sistemas como memoria, hilos, puglin's y demás. He decidido iniciar por este tema ya que es en teoría lo primero que deberias construir si iniciaras un proyecto en C++: tu manejador de memoria. En el título verán un "[1]" lo que indica que es la primera parte del artículo que está dividido en dos entregas.

Manejador de memoria:

Un manejador de memoria es un componente que te permite administrar de manera sencilla y fiel los recursos que maneja tu programa (software), específicamente el recurso de la memoria.

¿Porqué C++?

Es simple, en la mayoria de lenguajes utilizados actualmente este manejo se hace dinámicamente, hablamos de Java, Python, Php, Js, entre otros. Todos los lenguajes Scripting (que yo conozco) hacen el manejo de la memoria dinámicamente y por debajo: tu ni te enteras de lo que sucede; debo decir que este es precisamente uno de los principales problemas de los programadores en Java (NO TODOS pero si MUCHOS), ya que construyen su aplicación sin tener en cuenta el uso de la memoria y resultan con programas llenos de cualidades pero que se demoran 10 minutos y hasta 30 minutos en iniciar (no exagero, yo mismo los he visto). Por esta razón he elegido C++ como lenguaje de demostración, ya que aquí tienes que usar tanto NEW como DELETE para operar adecuadamente con tu recurso de memoria. Además, estoy desarrollando un proyecto en C++ y obligatoriamente me ha tocado trabajar en esta parte un poco antes de subir de nivel en el desarrollo.

¿Porqué Boost?
Por que es una biblioteca bastante decente y ofrece unas buenas implementaciones (en templates) de lo que vamos a necesitar en este apartado y como dicen por ahí: NO REINVENTES LA RUEDA.

Requisitos:
- Compilador de C++: en mi caso el Visual Studio (Visual C++)
- Boost: por lo menos los binarios de Smart Pointer del módulo de memoria. (Aquí tengo un post que explica como instalarlo en Windows XP).

¿Que es Smart Pointer?

Smart Pointer es lo mismo que un puntero de C++ solo que guarda unos cuantos datos extra además de la dirección de memoria del objeto al cual apunta. En la mayoria de casos guarda el dato del objeto al que apunta, es como si el puntero fuera el propietario del objeto. Y eso qué? bueno esto a simple vista no añade nada nuevo pero es bastante importante a la hora de evitar pérdidas de memoria, veamos la razón:

Cuando tienes algo como:


SceneManager * mSceneMgr = new SceneManager;

Internamente lo que sucede es que se declara el puntero de tipo SceneManager y se crea una zona de memoria donde guardas la información del "SceneManager" (en esta zona de memoria se guarda el objeto creado con new) y al puntero le asignas la dirección de memoria de esta zona creada para que se pueda acceder al objeto de tipo SceneManager. Hasta este punto todo va bien ..... pero y que pasa si tenemos esto:


void test ()
{
Node * tmpNode = new Node;
tmpNode -> setName ( "test leak" );
std::cout << "Nodo perdido: " << tmpNode -> getName () << std::endl;
}

Bueno si no se nota, en esa función falta una línea de código para que todos seamos felices:

delete tmpNode;

Incluso, en muchos proyectos he visto que hacen esto:

void test ()
{
Node * tmpNode = new Node;
tmpNode -> setName ( "test leak" );

// y hacemos algo como:
tmpNode = NULL;

// o:
tmpnode = mSceneMgr -> getNode ( "otronodo" );
}

Y violá, acabamos de perder la única forma de poder liberar la memoria que habiamos solicitado utilizando el operador "new" :S ya que al re-asignar el puntero a NULL o a otro nodo hemos perdido la dirección de memoria de nuestro objeto creado (el que se llama "test leak") y por tanto no podremos liberar la memoria que reservamos para éste: Jodidos!!!

Bueno este es uno de los principales problemas presentes a la hora de desarrollar proyectos en lenguajes como C o C++ (en C sería usando malloc y free): El software pide y pide y pide y nunca libera hasta que se nos consume gran parte de la memoria (o todo en el caso de algunas aplicaciones muy comelonas ¬¬).

Este es el primer problema que podemos resolver con un Smart Pointer ya que en sus implementaciones generalmente se conserva internamente el dato del objeto al cual se apuntaba inicialmente (por esto se usa template) y al momento de re-asignar lo que se hace es liberar primero la memoria que se está ocupando y luego si la asignación nueva (esto lo veremos mas claramente abajito).

Otro problema aún mas complejo es cuando tenemos algo como esto:

void test ()
{
Node * tmpNode = new Node;
Node * tmpNodeError = tmpNode;
.... // más código por aca.

delete tmpNode;
// luego algo como:
std::cout << "Error: " << tmpNodeError -> getName () << std::endl;
// o:
delete tmpNodeError;
}

En este ejemplo se da una doble liberación de memoria (es más común ver esto) y estoy seguro de ustedes ya saben que pasa cuando esto sucede: Bump bump bump!!! Y sale un mensaje diciendo: "deseas debuggear con Visual Studio?" al cual la mayoría de usuarios de nuestro programa no sabrán que contestar, bueno esto si tienes el VS instalado, sino saldrá algo como: "Error 0x000005c Error al ejecutar la aplicación, la reinstalación de ésta podría resolver el problema": Ambos nos llevan al mismo final: Jodidos!!!

Este es otro problema que nos resuelve utilizar Smart Pointers ya que tienen una implementación de "colector de basura" que nos permite saber cuando realmente liberar memoria y cuando NO!, todo sin que nosotros tengamos que ponernos a trabajar a bajo nivel haciendo seguimiento de todos los punteros que utilizamos en nuestra aplicación "EMPRESARIAL".

--
Notas de implementación:

Si vas a implementar tu propia clase de SmartPointer, te recomiendo (lo dice la literatura, no yo) NO utilizar funciones miembro (métodos) en la clase SmartPointer excepto:

Constructor
Destructor
Operador "->"
Operador "&"
Operador "*"
Operador "="

Y algunas otras como operaciones de comparación. Los dos primeros son muy importantes, los 4 últimos son sobrecarga de operadores, esto es necesario ya que hablamos de PUNTEROS y es necesario conservar al programador que haga uso de nuestra implementación de SmartPointer en el mundo de los punteros y no pasarlo al mundo de los objetos.

También es muy recomendado utilizar una clase "Template" por cuestiones de rendimiento y por la misma naturaleza de esta clase "SmartPointer" ya que se necesita declarar un SmartPointer que apunta a una clase T (Cualquier clase T).

Template
class SmartPtr
{
};

Igual este punto es al gusto del consumidor ya que existen dominios en los que abstraerse tanto no es algo bueno o da problemas de rendimiento y tal vez no añada mayor cosa.

Una posible implementación sería algo como:


Template
class SmartPtr
{
public:
explicit SmartPtr(T* pointee) : pointee_(pointee);
SmartPtr& operator=(const SmartPtr& other);
~SmartPtr();
T& operator*() const
{
...
return *pointee_;
}
T* operator->() const
{
...
return pointee_;
}
private:
T* pointee_;
...
};

En los SmartPointers la parte mas importante es el "manejo de propiedad" que permite indicar el objeto del cual es dueño el puntero (para liberar, copiar, etc.). Para esto hay varias técnicas que no discutiré profundamente en este documento pero si las voy a tratar de listar, la lista la pondré en inglés ya que es mas sencillo buscarlas en Google para quienes deseen profundizar en este tema:

Deep Copy: Cada SmartPointer tiene una copia del objeto al que apunta, relación: 1 - 1 entre el puntero y el objeto apuntado. De esta manera es super sencillo el manejo del objeto y su memoria asignada. El destructor del SmartPointer llama a delete ante el objeto y listo. Es la estrategia mas sencilla que existe.
Copy on Write (COW): Esta es una evolución de la anterior que expone: solo copie el objeto apuntado cuando se intente modificar a éste. (llamada al operador -> sobre el puntero).
Reference Counting: La chica mas popular de todas. Esta técnica es sencilla pero efectiva, lo que hace es mantener un contador que indica cuantos SmartPointers apuntan al mismo objeto apuntado, cuando este contador es igual a cero el objeto es borrado (libera la memoria). Existen una cantidad bastante grande de implementaciones de este método que varían en la ubicación de contador:

Si lo ponen en la clase SmartPointer lo que dobla el tamaño de la clase y esto no es tan bueno ya que esta clase es como un "puntero" y no debería ser grande en tamaño por su uso (cantidad de uso).
Si lo ponen en otra estructura que contenga el objeto apuntado y el contador (int), esta no incrementa el tamaño del SmartPointer pero si hace lento el acceso al objeto apuntado ya que se añade un nivel mas "SmartPointer ----> estructura ----> objeto apuntado" y lentejiza las operaciones de acceso.
Poner el contador en el objeto apuntado, es la mejor de todas las opciones ya que no incrementa en tamaño del SmartPointer y tampoco añade un nivel mas de acceso, esta ténica es llamada: "intrusive reference counting" ya que el contador es como un "intruso" dentro del objeto apuntado. Lo que recomienda la literatura es utilizar esta opción donde sea posible y la primera en el resto de casos.

Reference Linking: Es como una evolución del anterior. Se plantea la NO necesidad de saber cuantos SmartPointers apuntan a un objeto, lo UNICO que necesitas realmente es saber cuando NO hay objetos apuntando a el objeto (countRef == 0). Para realizar esta implementación se debe utilizar una lista doblemente enlazada (no listas simples ni vectores por tiempos de operación en ambas), esta implementación es mas pesada que el conteo ya que necesitas 3 punteros (el que apunta al objeto apuntado, el del siguiente elemento y el del elemento anterior). Además de esta desventaja, las operaciones sobre un SmartPointer con conteo son mas simples (asginacion e incremento) que las que se deben ejecutar sobre un SmartPointer con Reference Linking (operaciones de punteros)

En general ambas técnicas de manejo de referencias tienen la desventaja de que se pueden presentar referencias ciclicas cuando tienes un objeto A con un SmartPointer a un objeto B y B tiene también un SmartPointer al objeto A, aunque dejes de utilizar uno de ellos, al ser ciclico el otro lo mantendrá vivo y nunca serán liberados (la memoria) de ninguno de los dos. Este problema parece pequeño pero generalmente se logra extender en proyectos grandes generando complicaciones que, además, son bastante complejas de debuggear. En general y apesar de sus problemas, esta estrategia (manejo de referencias en cualquiera de sus dos variaciones) es la mas robusta, rápida y sencilla de las que existe (según la literatura y experiencia personal), solo es cuestión de tener cuidado para evitar problemas como la referencia ciclica y listo, pero en general hace la vida y el manejo de memoria mucho mas sencillo que cualquier otra opción.

Destructive Copy: Como su nombre lo dice, destruye el objeto apuntado en el SmartPointer original cuando se copia o asigna a otro SmartPointer, de esta manera solo existirá un solo SmartPointer apuntando al objeto en todo momento. El problema de este método es que puede generarte problemas sobre los datos que almacenas, no sobre los datos que tiene el objeto apuntado sino sobre operaciones ejecutadas sobre el SmartPointer luego de copiarlo en otro. Es una excelente opción ya que implementa todas las características de un SmartPointer, esta estrategia está presente en el std::auto_ptr.

Hay muchas opciones al momento de elegir que tipo de implementación utilizar, de estas las mas utilizadas e importantes son: Deep copy, reference counting, reference linking y destructive Copy. La idea es que cuando utilices una lib de SmartPointer, ésta te de la opción de elegir que estrategia utilizar según tus necesidades.

Bueno creo que esto será todo por el momento, he explicado en que consisten los SmartPointer (también conocidos como "punteros inteligentes" por la propiedad de manejar la liberación de memoria automática que NO tiene un puntero normal), expliqué las técnicas utilizadas para el control sobre la propiedad del objeto apuntado, pros y contras.

En el siguiente post trataré de explicar un poco mas sobre la implementación de esto, que pasa con los arrays (que son punteros también) y otras cosas para finalmente dar ejemplos de las cinco opciones que nos da Boost en este aspecto.

Por cierto, las presentaciones de las clases no las he podido subir por que no he podido cambiar el fondo pero espero hacerlo mañana. Bye

Noticias Sobre el mundillo de los video juegos

2009-02-12T15:25:00.000-08:00

Bueno la cosa se ha estado miviendo un poco por estos dias, la verdad estoy un tanto emocionado y pues voy a actualizarlos con lo ultimo que ha pasado:

--
Desde EichNews On-line me han comentado la apertura de un concurso de modelado, el concurso consiste en modelar una chica, lo que sería la chica de tus sueños jejeje. está dirigido a tod@s y da inicio YA¡¡ jejeje y termina el 1 de Mayo. Entre los premios está ser portada de la revista con tu modelo. Este para mi es el premio mas interesante y bastante útil para iniciar en este mundillo y darse a conocer un poco.

Los requerimientos para participar y una información mas amplia la encuentras en este foro: http://www.foro3d.com/f39/buscando-a-la-chica-cg-71199.html

En un panorama un poco mas regional tenemos a Andrés de AMGO y Digital Media Tutor quien me cuenta que este lunes tendremos la oportunidad de disfrutar de una conferencia con temas como video juegos y motores de video juegos - unreal engine 3 para ser precisos, la hora queda pendiente de confirmación pero solo pasate por el site de DMTutor y lo verás, según me cuentan en un rato estará publicada la información completa. Yo trataré de estar presente.

Además, en DMTutor están en este momento planeando un curso de modelado 3d básico, por favor señores visiten este link (http://www.dmtutor.com/index.php/educacion.html) para que tengan los datos concretos del asunto, en mi opinión personal creo que el curso es interesante y en cuanto al precio creo que es adecuado, además tiene varias facilidades que te pueden conseguir unas rebajas interesantes de hasta un 50% si sabes combinarlas adecuadamente.

--
Y para terminar informo que para el domingo estarán subidas en este blog (utilizando slideshare) las presentaciones que he escrito para el curso que dicto en la Universidad ICESI [Cali, Colombia] sobre diseño de video juegos. Hasta el momento solo hay dos que tratan los temas: Historia y Guión Literario. Estos recursos serán publicados bajo licencia CC, la información completa estará el Domingo.

--
Por ahora no es mas, nos vemos mas adelante.

Algunas noticias [realidad idiota]

2009-02-05T08:04:00.000-08:00

Llego a la oficina, inicio mi sesión de gmail y me topo con algunas de estas noticias que ahora compartiré con ustedes.

La idea:

Ver si es una cadena mas o si de verdad es algo que sucederá, es un mero experimento para ver a quien creer.

Aca está el mail:

+++++++++++++++++++++++++++++++++++++++++
Señores:
AHORRADORES(AS) COLOMBIANOS(AS)

De todas las entidades bancarias

DENUNCIA PÚBLICA

Soy empleado bancario, miembro de la junta directiva de uno de los bancos más prestigiosos de este país.

Por la denuncia que voy a hacer a continuación me es imposible revelar mis datos personales, pero por mi sentido profundo de patria y el dolor moral que me causa lo que adelante voy a denunciar, me veo en la necesidad de decirlo en esta carta que invito a todas las personas a quienes les llega que la reenvíen a la mayor cantidad de colombianos posible.

Los tiempos que se vienen en términos de economía son los más difíciles que todo el mundo haya tenido desde la crisis de 1929, esta crisis golpeará todos los sectores de la economía y como era de esperarse los grandes empresarios y banqueros por medio del Estado, han empezado a tomar medidas económicas para que su dinero no sea afectado. Como es tradicional, estas medidas recrudecen la situación económica de los más pobres, es decir, el grueso de la población colombiana.

Medidas como el recorte en el gasto público, disminución del salario mínimo y garantías laborales, aumento de tasas de interés, extensión del 4x1.000, estrategias de quiebra de las pequeñas empresas para quitar a la competencia y aprovechar los pequeños nichos de mercado, sanciones a prestamistas y formas distintas de comercialización como las compraventas, quiebra de mecanismos de ahorro alternativos a los bancos como las cooperativas y las pirámides ilegales que pusieron en un verdadero JAQUE al sistema financiero, están dentro de un abanico de acciones que han empezado a ser ejecutadas.

Lo más triste, inescrupuloso e inmoral del sector bancario se pudo observar en una reciente reunión de la junta de Asobancaria, en la cual uno de sus miembros mencionó que la medida a tomar ante la crisis es la misma que tomó el gobierno argentino De la Rúa durante la pasada crisis económica, el famoso "Corralito argentino", en el
Cual los bancos para no quebrarse prohibieron el retiro de dineros de sus ahorradores.

Sí, ESTIMADO COLOMBIANO, aquí en Colombia va a haber un CORRALITO BANCARIO y está previsto para los primeros días de mayo de 2009, ya es una decisión tomada y la crisis que esto va a generar, será una de las más grandes que haya tenido nuestra historia.

Otro banquero sin escrúpulo alguno dijo textualmente:
"SI LA GENTE SE PONE BRAVA, NOSOTROS TAMBIÉN NOS PONEMOS BRAVOS", lo cierto es que los banqueros no van a perder sus millones.

Ante esta situación me veo en la obligación de invitar a todos los colombianos a tomar estas medidas:

1. Retirar todos los ahorros que tengan en sus bancos, ahora es más rentable tener el dinero como lo hacían nuestros abuelos: debajo del colchón. LOS BANCOS NO PUEDEN DEVOLVER EL DINERO A TODOS
SUS AHORRADORES, ya que no tienen el respaldo real de nuestros dineros. ¿Por qué creen que nos invitan a pagar los servicios por medios electrónicos?, o ¿Por qué creen que invitan a todo el mundo a pagar con tarjeta de crédito o débito? Esto quiere decir que quienes retiremos primero nuestro dinero, no lo perderemos.

2. No endeudarse con bancos,ni utilizar, ni dejarse convencer de tener tarjeta de crédito. Colombia tiene una de las tasas de interés más altas de toda Latinoamérica, mientras en países como Venezuela prestan al 10% anual, en Colombia la tasa de interés llega al 30% anual. Si ya tiene un crédito y no puede pagar las cuotas, NO LO HAGA, no podrán judicializar a todos lo colombianos que no paguen sus deudas.

3. Emplee nuevas formas de suplir sus necesidades como intercambios o trueques, esto funcionó muy bien en Argentina mientras la crisis se superaba.

4. Absténgase de gastar su dinero en cosas que no necesita, invierta sus ahorros en activos (Capital que genera ganancias), es decir, invierta en negocios, en finca raíz y en el peor de los casos, compre euros que es la moneda más estable y guárdelos debajo del colchón.

5. Los precios de la finca raíz van a bajar a causa de la crisis económica, procure conservar su casa, NO LA VENDA, los personajes adinerados de Colombia aprovecharán el momento para enriquecerse con los bajos precios de la vivienda.

6. Trate de buscar un empleo fijo y aprovisione su casa de alimentos, estos van a escasear cuando la crisis llegue a su pico. Aunque el Gobierno, los banqueros y los empresarios digan que Colombia está blindada a la crisis mundial, ES MENTIRA. Lo único que hacen es ganar tiempo para ellos. NOSOTROS TENEMOS QUE GANAR TIEMPO PARA NOSOTROS.

7. No crea en lo que dicen o dirán los medios en los próximos meses, ya existe un plan de desinformación. Vendrán atentados terroristas y otra serie de acciones, con el fin de desviar la atención de la grave crisis económica. NO SE DEJE ENGAÑAR.

Agradezco a todos los que creen estas palabras, espero que este correo sea reenviado a todos los Colombianos, es preferible que los ahorros de toda nuestra vida se queden en nuestras casas y no en los bolsillos de los banqueros.

Recuerde que durante años ellos tuvieron multimillonarias ganancias y de eso los ahorradores no pudimos ver nada, mucho menos vamos a esperar algo bueno de los bancos en estas épocas de crisis.

Atentamente,
Empleado Bancario,
Miembro junta directiva de un banco colombiano.

+++++++++++++++++++++++++++++++++++++++++

Bueno este es el mail literal (ni le di formato siquiera), lo tendremos aca y en la mitad Mayo y a sus finales volveré a postear para que veamos si es realidad o mentira y podamos concluir si estamos ante el pastorcito mentiroso :D, por mi parte no pierdo mucho si es realidad ya que en mi cuenta hay en este momento unos 30 mil pesos que es todo lo que tengo jajajajaja :P, amanecerá y veremos.

Por otra parte también deseo compartir esta noticia que si es realidad link de la noticia:
http://ciberderechos.barrapunto.com/ciberderechos/09/02/05/0724213.shtml
+++++++++++++++++++++++++++++++++++++++++
Leo en una entrada de un blog que se ha filtrado un borrador del ACTA (Anti-Counterfeiting Trade Agreement), un convenio liderado por USA que se está negociando de forma muy poco transparente (como parece ser ya habitual) entre diferentes países, y que pretenden que se convierta en el nuevo marco que regirá los derechos de reproducción y de explotación monopolística de obras intelectuales y marcas registradas. Según ese borrador, el p2p de obras bajo restricción de copia para uso privado sin ánimo de lucro será perseguido legalmente en todos los países que lo ratifiquen, entre los que se encontrará la Unión Europea sin lugar a dudas, que también está participando en su negociación. Al parecer quieren dejarlo todo bien atado para 2010.
+++++++++++++++++++++++++++++++++++++++++

Como dice quien publicó la noticia, a este paso terminaremos todos en la carcel :S :P, será que el mundo se está volviendo idiota? por que loco está desde hace ya un buen rato .. pero idiota? bueno solo esperemos que no, por que a este paso si mi hermana me presta el carro KIA la demandará por derechos de autor y por que está evitando que yo compre un carro ... o si yo presto un libro entonces la editorial me demandará por derechos de autor por haber prestado el libro. Solo falta que le pongan patente al kamasutra:

la del misionero, la rusa, la mecedora y el 69 son propiedad de ********* compañía y para practicarlas tienes que pagar una de las siguientes esquemas de licencia:

500 Euros si la practicas con alguien del sexo opuesto
750 Euros si lo haces con alguien del mismo sexo
2000 Euros si lo haces con dos personas
Para grupos mas grandes y orgías toca llenar la forma azúl (azúl claro ¬¬) indicando cuantas personas de cada sexo van a estar presentes, edades y si solo lo van a hacer con los del sexo opuesto o si es todos contra todos. Además toca decir si con mas de una persona al tiempo o solo uno a uno, una vez entregada esta información a la compañía, se procesará la solicitud y en el plazo de 1 mes se recibirá la respuesta (que también será publicada en internet con nombres) del valor a pagar por las licencias necesarias para poder hacer uso de estas poses.

Jajajaja definitivamente el mundo se está volviendo idiota.

Qué piensas de patentar las poses y el kamasutra?

Game Engines: el cerebro detras del poder [Unreal Engine 3]

2009-02-01T09:28:00.000-08:00

Hablando tanto de video juegos y cosas así creo que es buen momento para hacer un pequeño inventario de lo que hay tras de los títulos mas aclamados de este momento en la industria de los video juegos: los Game Engines (Motores de video juegos).

La idea de un game engine es simplemente facilitar la producción de aplicaciones que hacen uso de estas tecnologías (gráficos 3d, sonido 3d, simulación de físicas, etc.), un game engine es para los juegos lo mismo que un CMS es para un web site. Como hacen para facilitar la producción de títulos: encapsulan tareas comúnes de los video juegos en rutinas fáciles de utilizar y bien estructuradas, de esta manera el estudio no tiene que preocuparse por como renderizar los vértices o como cargar y compilar un shader o como leer las entradas del usuario; en su lugar se enfocan en que hacer con esas entradas leidas, que vértices mostrar (modelos, contenido 3d), que shaders hacer para construir sus efectos especiales.

Sin mas ni mas, les presento a los artistas:

Unreal Engine 3

Este es quizá el game engine mas conocido en la actualidad ya que sobre él se han desarrollado la mayoría de los juegos mas populares de next-gen que hay en el mercado actual (2007-2008). La casa desarrolladora se llama Epic Games, un estudio norteaméricano que ya ha publicado varias versiones de su magistral obra (3 en total). Y no es para menos que este sea el motor mas elegido por todas las casas desarrolladoras de video juegos (y desarrollo 3D) o por lo menos, el mas deseado. Para dar soporte a esto entendamos un poco su forma interior y exterior:

Tecnología Unreal

General:

Dentro de lo principal de este engine está suportabilidad, pudiendo usarse para casi todas las consolas existentes actualmente:

XBox, XBox360
PlayStation 2 y 3
PC (Windows y Linux)

Esto es algo que todos los desarrolladores buscamos ya que la idea es llegar a la mayor cantidad de público posible.

También tenemos

Soporte para multicore en todas sus partes (incluyendo el render)
Herramientas gráficas para artistas, con las cuales se puede crear todo el contenido para el video juego, desde los niveles, shaders, armaduras físicas para objetos 3d, acondicionar luces, neblina, probar animaciones y definir secuencias, tomar video y otras tantas. Esto reduce mucho el trabajo de los programadores y es una de las principales fortalezas de este Engine, como lo ves queda.
Por la parte de programación no se queda atrás, el entgine tiene un potente lenguaje de scripting que soporta orientación a objetos (con sus características). No necesita ser compilado para verlo funcionando. También tiene una potente API con bindings de todo el engine en el lenguaje scripting. Finalmente y como si fuera poco te incluyen gran parte de las fuentes del juego Gears of War (bueno eso hasta el año pasado, no se si aún lo harán) para que te guies.

Con lo que vamos hasta ahora creo que es suficiente razón para ser el mas deseado por todos. Pero ¿y que? ¿acaso eso mismo no lo dan otros engines (excepto las fuentes del gears of war)? Seguramente que si, conozco muchos engines que también tienen editores gráficos para todo, tienen scripting y herramientas para mil cosas pero muy pocos lo presentan como lo hace la gente de Epic.

Render:

En este apartado definitivamente este engine se lleva CASI todos los premios, tiene TODOS los efectos de ultima, postprocesamiento, etc. Hagamos una lista de características para verlo mas en detalle:

Soporta render en multi-hilo, lo que ya es mucho decir en un game engine, esto permite obtener mejores fps's y aliviana la carga.
Soporte para HDR, corrección de color, desenfoque de movimiento (blur), bloom, profundidad de campo, oclusión ambiental, visión nocturna y mil efectos mas que pueden ser definidos por los artístas directamente y no por los ing.
Soporta todas las tecnicas de iluminación y texturizado incluyendo normalmapping, phong, mapas de desplazamiento, mapas de iluminación, etc.
Tiene también bien definido el sistema de render y la abstracción de lo que es dependiente de plataforma para poder ser portado (esto permite su ejecución en tantas plataformas tan distintas)
Soporte de todas las técnicas de sombreado, mapas precalculados, sombras volumétricas y suaves.
Sistema de partículas potente.
Soporte de shaders en todas las plataformas así como cache de los mismos.
Sistema de materiales y sistema para efectos post-procesamiento, ambos extendibles al gusto del consumidor.
Soporte de efectos como render a textura, multiples viewports.
Animación con track de cámaras y en meshes por huesos y morphing
Manejo de LOD's estáticos (no estoy seguro de si denámicos pero creo que si)
Fog volumétrico y clouth que pueden ser utilizados en cualquier entorno a gusto y discreción del artista.
Soporta todos los manejadores de escena necesarios para el trabajo incluyendo portales
Generación de terrenos con editor que permite su construcción dinámicamente. Manejo de texturas sobre los terrenos que soportan todo el framework de materiales, incluyendo mapas de desplazamientos (sobre el terreno), mapas de normales y efectos personalizados hasta el punto que desees.
También manejo de terrenos con generación de vegetación con uno de los partners llamado SpeedTree. Todo esto soportando técnicas de LOD y mapas de iluminación.
Integración de GUI 2D y 3D por mesh o textura y también se integra con ScaleForm (la gui de crysis) para hacer GUI's de calidad inigualable.

Como se ve, en este apartado este engine tiene todo lo necesario para ser uno de los mas usados en la industria de los video juegos y en general de gráficos 3d. Pero la cosa no termina aquí, veamos ahora el apartado de animación:

Animación:

Es posible que para muchas personas esto no sea algo que implique dedicación completa de ingenieros y un framework independiente, muchos pensarán que es solo realizar las animaciones en un programa de diseño tipo 3dMax y luego pasarlas al motor y darle "Actor.setAnimation ( "walk" )" y ya está, tenemos al muñeco corriendo. Bueno, esto es cierto, con algo tan sencillo como eso puedes poner al personaje a correr por el entorno, pero no te olvides de algunas cosas como: ¿Qué pasa si voy a saltar, ejecuto la animación de salto (jump)? ¿Si lo hago, que pasa en la parte visual, se ve un brindo de la animación de correr a la de saltar? ¿Y que pasa si al personaje le han dado algunos tiros? ¿no debería ejecutar la misma animación de correr pero con una pequeña modificación para que se note el disparo? Pues bueno, todo esto es cierto. Si vas de una animación a otra se verá un brinco brusco en el juego y esto por cada cambio de animación, por esta razón, este punto también es importante en video juegos, es algo que consume muchos recursos y es muy estudiado por las compañías expertas en este tipo de programas.

En el caso que nos importa en este momento tenemos lo siguiente:

Soporte de animaciónes por huesos y morph
Blending entre animaciones, esto permite pasar de una animación a la otra sin tanto trauma utilizando algoritmos de iterpolación entre puntos.
Herramienta visual para navegar por las animaciones y organizarlas (además de poder probarlas y cuadrar algunos valores en ellas).
En dicha herramienta también hay algo que es bien útil y es la posibilidad de ver sobre el mismo esqueleto (animación) los meshes que serán guiados por éste, en el caso de un personaje: armaduras, armas, escudos, etc.
El UnReal3 también soporta físicas sobre las animaciones de manera que pueden verse alteradas un poco en respuesta de eventos físicos durante el juego, para esto hay que definir algunas propiedades físicas de los objetos que son afectados por los huesos.
Cinemática inversa que nos permite tener mas precisión sobre los objetos al momento de graficarlos en el entorno 3d, un ejemplo bastante bueno de esto son los juegos prince of persia (aunque no están sobre este engine utilizan la misma técnica), en este juego podemos ver al protagonista "el principe" cuando escala paredes que sus manos se ubican bastante bien respecto a la irregularidad de las paredes y bordes donde se posan.
Otra cosa importante es que en el editor de animaciones (del árbol de animaciones "AnimTree") se pueden crear complejas secuencias de animación y previsualizar, esto con el fin de observar las secuencias y sus respectivos blendings, con esta información se pueden realizar correcciones sobre las animaciones si alguna no sale bien formada.

Esto es lo mas relevante en este punto, adicional creo que puedo mensionar que el Unreal 3 trabaja con la tecnología de Natural Motion lo cual permite lograr animaciones mucho mas complejas y realistas, dentro de sus técnicas, hay algunas que permite generar animaciones desde los datos del juego, es decir que las genera el computador (a diferencia de lo tradicional donde es el diseñador quien las hace y un algoritmo de interpolación) tomando información del juego y del entorno, no tengo el dato de hasta que punto trabaja pero los demos se ven increibles, en este momento estoy bajando la versión trial para analizarla.

Otro punto importante en este engine (y en todos hoy en dia) es el apartado de sonido, veamos como está esto:

Sonido:

En esto no es que exista mucho para escribir jejeje, cosas para resaltar:

Soporte de Ogg Vorbis
Abstracción bastante interesante que hace independiente la implementación de su uso pudiendo utilizar diversos dispositivos incluyendo sonido.
Soporte para sonido 3D con fuentes y atenuación
Efectos varios como eco, doppler, etc.
Soporte multi-canal (sonido 7.1 e inferior)
Soporte para varias cosas mas mmm.

Lo mas importante aca es su integración con el editor de niveles, lo que permite al diseñador ubicar y acomodar los sonidos y sus efectos y filtros.

En este apartado el Unreal Engine 3 hace uso de otras libs externas como FMOD y OpenAl e implementan su motor de sonido con ellas.

Físicas:

Este es uno de los motores que tiene mejores físicas, integra el motor de nVidia PhysX (antiguo Novodex de Ageia) para dar soporte a todo lo referente a simulación de físicas de última generación con soporte para:

Físicas de cuerpos rígidos, colisiones e interacción entre objetos dinámicos y estáticos.
Controlador de personaje
Ragdolls para muertes y en general caidas de personajes mas reales
Físicas de vehículos y objetos destruibles
Partículas
Simulación de tela, cuerdas y cuerpos blandos
Maneja materiales para los objetos, esta es una característica que permite definirle a los objetos del juego sus propiedades físicas (bueno las de sus superficies como fricción, rozamiento, etc., distintas a las propiedades físicas del objeto como tal).

Hay otras características pero estas son las mas importantes junto con su integración al editor de niveles, lo que permite crear los esqueletos "físicos" de los personajes para colisiones, ragdolls y demás eventos físicos utilizados en el juego. Adicional también puedes definir uniones y la cantidad de fuerza necesaria para romperlas, con esto puedes tener por ejemplo desmembración de cuerpos u objetos destruibles (como casas y vehículos).

Editor:

Es una herramienta que como ellos mismos la describen en su web "como lo ves, lo tienes". Es un editor que integra varias herramientas especializadas para la creación de todo el contenido del video juego.

Este editor se complementa perfectamente con herramientas de generación de contenido como 3dMax o Maya. En él puedes definir casi todo lo necesario para el juego (casi que haces el juego en él), te permite manejar las luces, el escenario, definir los manejadores de escena, sombras y objetos estáticos.

Este editor incluye entre otras herramientas lo siguiente:

Editor de terrenos: Permite generar el terreno y hacer edición directa sobre la grilla del terreno, además integra también una herramienta de pintura que te permite definir zonas y como debe ser el blending (o la transición) entre una zona (pasto verde) y otra (desierto).

Editor de materiales: Permite generar y editar visualmente los materiales y shaders. Esta es una gran herramienta ya que los diseñadores definen de una vez visualmente los efectos del juego

Editor de Meshes: Importantísimo ya que te permite visualizar los objetos 3d, definir su "esqueleto" físico, propiedades físicas, generación de los LOD's e incluso fracturarlos para poder utilizarlos como objetos "rompibles" en el juego.

UnrealPhAT: Esta herramienta permite trabajar todo lo relacionado con el apartado físico de los objetos del juego, por ejemplo la creación de los ragdolls.

UnrealKismet: esta es una herramienta de programación visual, utilizandola los diseñadores gráficos y de nivel pueden definir comportamientos sobre los objetos, estos comportamientos deben ser sencillos pero puedes tener muchas relaciones entre ellos permitiendo así llegar a estructuras mas complejas y finalmente exportando a código que puede ser personalizado por los programadores.

UnrealMatinee: con la cual se pueden crear secuencias de animación desde el engine para definir cinemáticas que son usadas en el video juego. En esta herramienta se puede jugar con la cámaras, definiendo cambio entre ellas, secuencias, paneos. Además puedes definir y modificar efectos de postprocesamiento en tiempo real e ir viendo cual será el acabado final del video.

UnrealCascade: permite crear efectos de partículas en cualquier momento, visualizarlas y empalmarlas al video juego como tal.

Editor de Interfaz de Usuario (UI): con el cual puedes definir como será la interfaz para interactuar con el usuario, esto "CREO" que no se integra con el ScaleForm, ya que en ese caso se utiliza Flash como editor de la GUI se ponen los assets (recursos) disponibles para su carga en el engine y visualización. Respecto a la interacción, ScaleForm tiene una api en ActionScript 2.0 y además es capaz de interpretarlo así que esto queda delegado a ScaleForm, el Unreal lo que hace es integrarlo a su API para que sea utilizado de forma transparente.
Editor Sound Cue: con este editor básicamente lo que podemos hacer es ubicar las fuentes de sonido, definir los sonidos y algunas propiedades sobre éstos (filtros y efectos).
Editor de efectos de Post-Procesamiento: Algo muy básico que permite definir algunos parámetros de este tipo de efectos.

Todo esto integrado en una herramienta (de partes) que cubren casi todos los apartados de la creación de un video juego de cualquier género existente.

Por cierto, en el conjunto de herramientas olvidé mensionar los exporters que tiene para los programas de diseño utilizados actualmente para video juegos.

Scripting:

El último componente de este motor pero no el menos importante es este. El UE3 define un lenguaje scripting llamado el "UnrealScript" el cual tiene bindings de TODO el motor para que pueda usarse de manera casi que como único lenguaje sobre el cual se programa, es decir, casi podrías hacer un juego en su totalidad sobre este lenguaje sin necesidad de C++. Es mas, según tengo entendido actualmente los juegos se programan sobre este lenguaje script y solo cosas muy MUY específicas se realizan sobre lenguajes de mas bajo nivel como C++ (algún efecto, extender algún comportamiento físico o cosas similares).

Dentro de sus características mas importantes están:

Lenguaje fuertemente tipado
Similar a C++ en sintaxis pero sin los complejos "*, ->"
Manejo de objetos y colector de basura para manejo optimo de memoria
Independiente de la plataforma (máquina virtual)
Tiene una parte de networking robusta y compleja que soporta ejecución de funciones remotas (servidor y/o cliente), envio de paquetes y fragmentos con manejo de referencias para su construcción
Soporta interfaces
Y finalmente tiene una buena herramienta de debugger que ayuda bastante, creanme, soy programador.

En internet hay bastante materia de ayuda respecto a este lenguaje, recomiendo su lectura para hacerse a una pequeña idea.

Bueno, esto es lo que hace falta para poder tener títulos de calidad inigualable como lo son mirrors edge, bioshock o army for two. Una lista de sus casos de exito puede ser vista en este link: http://www.unrealtechnology.com/success-stories.php

Finalmente recomiendo ver la lista de partners de este gran game engine, esto es siempre importante ya que el motor nunca lo tiene TODO y en muchos casos hacen uso de herramientas externas para tareas específicas, lo que quiero resaltar con esto es que finalmente aunque un motor tiene mucho que es propio en CASI todos los casos involucran la integración de muchas herramientas externas mm y muchas de ellas de software libre.

Partners: http://www.unrealtechnology.com/partner-program.php Yo he tenido la oportunidad de trabajar con algunas de estas LIBS y debo decir que hay algunas "increibles". Recomiendo mucho su lectura y estudio.

Libs opensource presentes en el Unreal Engine 3: OpenAl y wxWidgets (en el editor), hay otras libs pero mas pequeñas en el Core.

Un par de capturas de lo que tenemos frente a nosotros con este game engine:

Y con esto termino esta primera entrada sobre game engines, la próxima hablaré sobre el afamado CryEngine2 con el cual hicieron los juegos Crysis y Crysis WarHead y Seguiré con Dunia de FarCry 2 (para mi este engine tiene un render perfecto a un MUY decente fps en máquinas promedio) y el Scimitar sobre el que corre la ultima entrega del Prince of Persia y el mismo Assassin's Creed.

Nos vemos.

Demigod

2009-01-27T08:24:00.000-08:00

Demigod

Gran título de estrategia en tiempos en los que ya no son tan impactantes o únicos como antes. Hoy se han liberado las especificaciones técnicas mínimas y recomendadas para ponerlo a andar.

Mínimos

Sistema Operativo: Windows XP SP3/Windows Vista SP1
MicroProcesador: 1.8 GHz
Memoria RAM: 512GB
Tarjeta Gráfica: Tarjeta gráfica de 128MB (GeForce 6800/Radeon 9800 o superior)
Tarjeta de Sonido: DX9.0c compatible
Versión de DirectX: 9.0c
Periféricos Soportados: Teclado, Ratón

Recomendados:

Sistema Operativo: Windows XP SP3/Windows Vista SP1
MicroProcesador: 3.0 GHz
Memoria RAM: 1 GB
Tarjeta Gráfica: Tarjeta gráfica de 256 MB (GeForce 7600/Radeon x800 o superior)
Tarjeta de Sonido: DX9.0c compatible
Versión de DirectX: 9.0c
Periféricos Soportados: Teclado, Ratón

Debo decir que hacia rato que no veía un video juego de buena calidad que pidiera requerimientos tan bajos: 128 en video, yo recuerdo que mi segunda tarjeta era una ATI de 128 aunque no recuerdo la referencia ... se la regalé al que era mi cuñado en ese entonces cuando compré la de 256 también ATI ... recuerdo que ambas las compré en la misma semana :P.

Bueno con requerimientos tan bajos será esperar a que llegue y probarlo, pero por lo que se ha visto este título promete grandes cosas.

Mi novela preferida: Mirror's Edge Walkthrough

2009-01-23T17:25:00.000-08:00

Jejejejeje, ya llevo un buen rato viendo el walkthrough de Mirror's Edge en video en youtube y debo decir que está super emocionante, es como ver una serie de televisión o algo así jajaja, te tiene pegado a la pantalla y quieres ver mas y mas cada vez :D. Efectivamente ya lo estoy jugando pero mi PC tiene problemas, cuando comienzo a pedirle mucho se apaga solo (la fuente de una), entonces creo que es por que tengo muchas cosas conectadas a la misma fuente y cuando pongo un juego de estos pues como que la exigencia es demasiado y la fuente simplemente se apaga inmediatamente.

Tengo una fuente de 600W y en mi PC tengo:

Dvd (quemador y lector)
1 DD Sata de 500G y otro DD Sata de 320G
Tarjeta de video 8600
Procesador 6000+
Tarjeta madre MSI no recuerdo jajaja

Será que es mucha carga para mi fuente, igual mañana me compro otra a ver que tal va :D

Bueno a lo que va, aca dejo los capítulos de esta espectacular serie de video juego jajaja :D para que todos la vean, pillense el final :D. OJO, antes pasen el juego o si son como yo y saber el final no les daña la historia pues veanlo de una :P

Prologo:

Prologo: Distrito financiero

Capítulo 1: Flight

Capítulo 2: Jacknife

Capítulo 3: Heat

Capítulo 4: Ropeburn

Capítulo 5: New Eden

Capítulo 6: Pirandello / Kruger

Capítulo 7: The Boat

Capítulo 8: Kate

Capítulo 9: The Shard

Y listo, espero los disfruten tanto como yo :P, pronto pondré mas.

Por cierto, en esta web están todos los Walkthrough que existen, en texto y video: http://www.mahalo.com/Category:Video_Game_Walkthroughs

Hawx y EndWar para PC en Marzo

2009-01-21T11:59:00.000-08:00

Excelentes noticias las que me encuentro hoy al entrar a mis sitios de consulta de este mundillo. Confirmado por la misma Ubisoft, Marzo es el mes elegido para los grandes lanzamientos

EndWar

Título que hasta el momento solo está disponible para Consolas, será publicado en el mes mensionado para compatibles (PC) según informó hoy en la mañana la empresa gala. Para mi es un gran acierto de parte de ellos ya que por su naturaleza este juego ha sido construido para ser usado en una PC mas que en cualquier otra consola. Asombrosos gráficos, un acabado impecable, buena trama y mucho mas que promete unas horas de gran diversión.

Ya se había convertido en mi piedra dentro del zapato pues estoy esperando desde que fue liberado para consolas en Noviembre a que fuera puesto para la PC, esperemos que nada suceda desde ahora hasta su fecha de liberación para poderlo tener en mis manos :P

HAWX

La verdad yo no soy amante de los emuladores de vuelo pero este hace una gran promesa respecto a su acabado convirtiendose en el mas ostentoso del género. Las gráficas son bastante buenas, los combates aéreos son dinámicos, en tiempo real, rápidos y frenéticos. Me imagino, todo el cielo para moverte, explorar y pelear: "La guerra del futuro será en el aire".

Ahora toca ser pacientes y esperar a que este señor sea entregado al público, cuando esto suceda seguramente haré mis comentarios al respecto, por ahora .... paciencia ...

Para terminar, Ubisoft también ha dicho que por desgracia este no será el mes para la publicación de "I am Alive", esto es una verdadera lástima ya que es un título también muy afamado por los medios, será solo hasta la segunda mitad del año que podremos disfrutar de el. Así es la vida :P

Mirror's Edge en PC ya está disponible

2009-01-16T08:11:00.000-08:00

Por fin tenemos este gran título para mi consola mas amada, el PC :P. Este juego fue una de las apuestas de EA del año pasado, (junto a Dead Space) desgraciadamente no les fue como esperaban aunque las ventas fueron bastante buenas diria yo. La estrategia de ellos fue dar el juego para consolas ps3 y xbox360 y un mes despues hacer la entrega en compatibles, esto para evitar la piratería aunque parece que no obtuvieron los resultados que esperaban en las consolas. Ojalá en PC la historia sea un poco distinta y se logre demostrar que esta consola de juegos también vale la pena.

Por ahora estoy en gestiones de conseguirlo para añadirlo a mi colección, pronto espero poder probarlo y añadir mi comentario sobre él.

Algo importante es tener en cuenta los requerimientos de este juego, los puse hace algún tiempo en este Post: http://valtovar.blogspot.com/2008/12/mirrors-edge-para-pc.html para que los tengan en cuenta a la hora de comprarlo.

Materia: Diseño de Video Juegos; Universidad: ICESI de Cali, Colombia; Profesor: Juan Diego Uran Correa (aka valtovar)

2009-01-15T14:21:00.000-08:00

La verdad esta semana ha estado llena de mil sorpresas, la mayoría agradables (aunque por desgracia no todas y eso tiene nombre PROPIO: Maria Fernanda) pero en fin, este post lo hago para comentar la buena nueva mas importante de esta semana que es la siguiente:

La Universidad ICESI de Cali, una de las mas importantes en computación y telecomunicaciones del Valle (Colombia) ha abierto un curso este semestre llamado "Diseño de Video Juegos" y me han pedido que sea el profesor del curso :D ... INCREIBLE .. jejejeje, esto es supremamente bueno para mi, para mi hoja de vida y mi experiencia, además que así se me abren mil puertas tras de esta, oportunidades tanto laborales como académicas, becas y demás cosas buenas que tiene trabajar con universidades. El curso ya inició pero apenas hoy se hizo formal mi contratación entonces obviamente no tengo nada aún, desde esta misma noche inicio labores estudiando y viendo que dan en otros lugares del mundo para ver que enseñan y así yo tratar de enseñar a las 15 personas (según me han contando) que tomarán esta electiva profesional.

Datos interesantes: Es una electiva profesional tanto para ingenieros en informática y telecomunicaciones como para diseñadores cosa que me anima MUCHO MAS a que si fuera solo para ingenieros ya que este mundo es de dos y uno no existe sin el otro.

Comentarios? Qué les gustaría ver en un curso de Diseño de Video Juegos con duración de 5 meses?

Qt sobre LGPL

2009-01-14T08:39:00.001-08:00

Buena noticia para todos aquellos de desarrollan software utilizando este gran framework, Nokia ha decidido que la siguiente versión de las Qt tendrán además de las dos licencias actuales (GPL y Comercial), la licencia LGPL. Esta es una gran noticia ya que esto permitirá a desarrolladores como yo poder comercializar sus proyectos sin pagar licencias comerciales a Nokia, obviamente hay algunas restricciones como que se debe linkear dinámicamente y algunas cosas de diseño en los productos, pero igual abre las puertas para muchos desarrolladores que si están dispuestos a acomodarse a estas restricciones.

Nokia también ha confirmado que seguirá trabajando con los otros dos esquemas de licencia y hace énfasis en la versión Comercial, ya que con esta tu tienes el control de todo, desarrollas como gustes y no tienes restricciones (a diferencia de la LGPL).

Adicional a esto hay dos cosas mas, la primera es que esta nueva versión de Qt, la 4.5 estará disponible en Marzo de este año (2009) y la segunda que el sitio web de Qt cambia del actual www.trolltech.com a www.qtsoftware.com

Definitivamente es una gran manera de iniciar este año para todos los desarrolladores que nos beneficiamos de las herramientas de alto nivel y calidad que hay disponibles en la comunidad como por ejemplo Qt.

Fuente de la noticia oficial (en ingles): http://www.qtsoftware.com/about/news/lgpl-license-option-added-to-qt

F.E.A.R. 2: Project Origin

2009-01-12T09:49:00.000-08:00

Project Origin

Bueno este juego ya está llegando a su recta final, a un mes de ser publicado ya se hicieron públicos los requerimientos de hardware para PC y como en anteriores entregas, aca los tenemos:

Mínimos

Sistema Operativo: Windows XP SP2/Windows Vista SP1
MicroProcesador: Pentium 4 2.8GHz (3.2GHz en Vista)/Athlon 64 3000+ (3200+ en Vista)
Memoria RAM: 1GB (1.5GB Vista)
Tarjeta Gráfica: Tarjeta gráfica de 256MB (SM 2.0b) compatible con DirectX9. NVidia 6800 o ATI X700.
Tarjeta de Sonido: DX9.0c compatible
Versión de DirectX: 9.0c
Espacio en Disco Duro: 12GB
Periféricos Soportados: Teclado, Ratón

Recomendados:

Sistema Operativo: Windows XP SP3/Windows Vista SP1
MicroProcesador: Core 2 Duo 2.2GHz /Athlon 64 X2 4400+ (requerido para ser el host del multijugador)
Memoria RAM: 1.5GB
Tarjeta Gráfica: Tarjeta gráfica de 512MB (SM 3.0). NVidia 8600 GTS o ATI HD 2900 XT.
Tarjeta de Sonido: DX9.0c compatible
Versión de DirectX: 9.0c
Espacio en Disco Duro: 12GB
Periféricos Soportados: Teclado, Ratón

Cosas usando JME

2009-01-08T14:54:00.000-08:00

En el proyecto de colciencias Comcity estoy usando el motor de juegos JMonkey Engine, es un motor que tiene mucho para ofrecer, GUI 3D, físicas, render bastante bueno, sonido y mil cosas mas que ya vienen nativas en Java. Mi experiencias con él ha sido mas bien escasa pero he logrado aprender ciertas cositas interesantes y pues una de ellas es la que pondré aca:

Como añadir un nodo a la escena de una forma segura?

Resulta que al estar en Java, el motor usas varios hilos, uno para el update y otro es el render de OpenGl (a eso sumarle los hilos que cada cual use en su aplicación), debido a esto hacer un simple

URL modelToLoad = Item.class.getClassLoader ().getResource ( "Media/Torres/Models/Autosoportada/base.3ds" );
MaxToJme C1 = new MaxToJme ();
ByteArrayOutputStream BO = new ByteArrayOutputStream ();
C1.convert ( new BufferedInputStream ( modelToLoad.openStream () ), BO );
maggie = ( Node ) BinaryImporter.getInstance ().load ( new ByteArrayInputStream ( BO.toByteArray () ) );
rootNode.attachChild ( maggie );

No es suficiente, ya que seguramente añade el objeto 3D, pero dará lios, en mi caso, los lios fueron sobre los materiales, no los ponia bien :S, así que lo que toca hacer es utilizar un mecanismo de colas de tareas que tiene el motor, con esto podemos pasarle el Nodo que deseamos añadir a la cola y listo, el motor se encarga de lo demás.

El proceso sería así:

Cargamos el Nodo (este fragmento puede estar en cualquier lugar de nuestra aplicación), este código carga un 3DS y lo convierte en un Node de JME.

URL modelToLoad = Item.class.getClassLoader ().getResource ( "Media/Torres/Models/Autosoportada/base.3ds" );
MaxToJme C1 = new MaxToJme ();
ByteArrayOutputStream BO = new ByteArrayOutputStream ();
C1.convert ( new BufferedInputStream ( modelToLoad.openStream () ), BO );
maggie = ( Node ) BinaryImporter.getInstance ().load ( new ByteArrayInputStream ( BO.toByteArray () ) );

Y luego ponemos este fragmento de código donde queremos añadirlo a la escena

 GameTaskQueueManager.getManager().update(new Callable()
{
       public Object call() throws Exception
       {
           rootNode.attachChild(maggie);
           rootNode.updateGeometricState(0, true);
           rootNode.updateRenderState();
           return null;
       }
});

Y listo, todo el código puede ir en el mismo método o como quieras, lo importante es este ultimo ya que se encarga de poner en la lista de ejecución el método que va a realizar la adición del mesh, recomiendo que la carga sea por otro lado ya que va en un hilo y que este fragmento del final vaya por otro lado ya que es su adición a la escena, es como cargar los recursos necesarios en fondo e irlos usando sobre el hilo principal cuando sea necesario.

Ultima cosa, para rotar un objeto:

Quaternion rot = maggie.getLocalRotation();
rot.fromAngleAxis((float)Math.toRadians(90), Vector3f.UNIT_X );
maggie.setLocalRotation( rot );

Aca tenemos primero averiguar la rotación del nodo, esta información nos la retorna el método "getLocalRotation" en forma de Quaternion, luego simplemente llamamos al método "fromAngleAxis" para rotar el Quaternion, debenos saber cuantos grados y sobre que eje, en el ejemplo, lo roto 90 grados sobre el eje X y finalmente le asigno esta información al Nodo como su rotacion. El método estático "toRadians" recibe un float (ángulo en grados) y lo pasa a radianes, es importante hacer esto ya que "fromAngleAxis" recibe el dato en radianes.

Nos vemos proximamente.

El corazón del Ogro: OgrePlatform.h

2009-01-07T10:15:00.000-08:00

OgrePlatform.h

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2006 Torus Knot Software Ltd
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.

You may alternatively use this source under the terms of a specific version of
the OGRE Unrestricted License provided you have obtained such a license from
Torus Knot Software Ltd.
-----------------------------------------------------------------------------
*/
#ifndef __Platform_H_
#define __Platform_H_

#include "OgreConfig.h"

namespace Ogre {
/* Initial platform/compiler-related stuff to set.
*/
#define OGRE_PLATFORM_WIN32 1
#define OGRE_PLATFORM_LINUX 2
#define OGRE_PLATFORM_APPLE 3

#define OGRE_COMPILER_MSVC 1
#define OGRE_COMPILER_GNUC 2
#define OGRE_COMPILER_BORL 3

#define OGRE_ENDIAN_LITTLE 1
#define OGRE_ENDIAN_BIG 2

#define OGRE_ARCHITECTURE_32 1
#define OGRE_ARCHITECTURE_64 2

/* Finds the compiler type and version.
*/
#if defined( _MSC_VER )
#   define OGRE_COMPILER OGRE_COMPILER_MSVC
#   define OGRE_COMP_VER _MSC_VER

#elif defined( __GNUC__ )
#   define OGRE_COMPILER OGRE_COMPILER_GNUC
#   define OGRE_COMP_VER (((__GNUC__)*100) + \
   (__GNUC_MINOR__*10) + \
   __GNUC_PATCHLEVEL__)

#elif defined( __BORLANDC__ )
#   define OGRE_COMPILER OGRE_COMPILER_BORL
#   define OGRE_COMP_VER __BCPLUSPLUS__
#   define __FUNCTION__ __FUNC__
#else
#   pragma error "No known compiler. Abort! Abort!"

#endif

/* See if we can use __forceinline or if we need to use __inline instead */
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
#   if OGRE_COMP_VER >= 1200
#       define FORCEINLINE __forceinline
#   endif
#elif defined(__MINGW32__)
#   if !defined(FORCEINLINE)
#       define FORCEINLINE __inline
#   endif
#else
#   define FORCEINLINE __inline
#endif

/* Finds the current platform */

#if defined( __WIN32__ ) || defined( _WIN32 )
#   define OGRE_PLATFORM OGRE_PLATFORM_WIN32

#elif defined( __APPLE_CC__)
#   define OGRE_PLATFORM OGRE_PLATFORM_APPLE

#else
#   define OGRE_PLATFORM OGRE_PLATFORM_LINUX
#endif

/* Find the arch type */
#if defined(__x86_64__) || defined(_M_X64) || defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || defined(__s390x__)
#   define OGRE_ARCH_TYPE OGRE_ARCHITECTURE_64
#else
#   define OGRE_ARCH_TYPE OGRE_ARCHITECTURE_32
#endif

// For generating compiler warnings - should work on any compiler
// As a side note, if you start your message with 'Warning: ', the MSVC
// IDE actually does catch a warning :)
#define OGRE_QUOTE_INPLACE(x) # x
#define OGRE_QUOTE(x) OGRE_QUOTE_INPLACE(x)
#define OGRE_WARN( x )  message( __FILE__ "(" QUOTE( __LINE__ ) ") : " x "\n" )

//----------------------------------------------------------------------------
// Windows Settings
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32

// If we're not including this from a client build, specify that the stuff
// should get exported. Otherwise, import it.
# if defined( OGRE_STATIC_LIB )
// Linux compilers don't have symbol import/export directives.
#    define _OgreExport
#    define _OgrePrivate
#   else
#    if defined( OGRE_NONCLIENT_BUILD )
#        define _OgreExport __declspec( dllexport )
#    else
#           if defined( __MINGW32__ )
#               define _OgreExport
#           else
#            define _OgreExport __declspec( dllimport )
#           endif
#    endif
#    define _OgrePrivate
# endif
// Win32 compilers use _DEBUG for specifying debug builds.
#   ifdef _DEBUG
#       define OGRE_DEBUG_MODE 1
#   else
#       define OGRE_DEBUG_MODE 0
#   endif

// Disable unicode support on MingW at the moment, poorly supported in stdlibc++
// STLPORT fixes this though so allow if found
// MinGW C++ Toolkit supports unicode and sets the define __MINGW32_TOOLKIT_UNICODE__ in _mingw.h
#if defined( __MINGW32__ ) && !defined(_STLPORT_VERSION)
#   include<_mingw.h>
#   if defined(__MINGW32_TOOLBOX_UNICODE__)
#     define OGRE_UNICODE_SUPPORT 1
#   else
#       define OGRE_UNICODE_SUPPORT 0
#   endif
#else
# define OGRE_UNICODE_SUPPORT 1
#endif

#endif
//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Linux/Apple Settings
#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_APPLE

// Enable GCC symbol visibility
#   if defined( OGRE_GCC_VISIBILITY )
#       define _OgreExport  __attribute__ ((visibility("default")))
#       define _OgrePrivate __attribute__ ((visibility("hidden")))
#   else
#       define _OgreExport
#       define _OgrePrivate
#   endif

// A quick define to overcome different names for the same function
#   define stricmp strcasecmp

// Unlike the Win32 compilers, Linux compilers seem to use DEBUG for when
// specifying a debug build.
// (??? this is wrong, on Linux debug builds aren't marked in any way unless
// you mark it yourself any way you like it -- zap ???)
#   ifdef DEBUG
#       define OGRE_DEBUG_MODE 1
#   else
#       define OGRE_DEBUG_MODE 0
#   endif

#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
#define OGRE_PLATFORM_LIB "OgrePlatform.bundle"
#else
//OGRE_PLATFORM_LINUX
#define OGRE_PLATFORM_LIB "libOgrePlatform.so"
#endif

// Always enable unicode support for the moment
// Perhaps disable in old versions of gcc if necessary
#define OGRE_UNICODE_SUPPORT 1

#endif

//For apple, we always have a custom config.h file
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
#    include "config.h"
#endif

//----------------------------------------------------------------------------

//----------------------------------------------------------------------------
// Endian Settings
// check for BIG_ENDIAN config flag, set OGRE_ENDIAN correctly
#ifdef OGRE_CONFIG_BIG_ENDIAN
#    define OGRE_ENDIAN OGRE_ENDIAN_BIG
#else
#    define OGRE_ENDIAN OGRE_ENDIAN_LITTLE
#endif

// Integer formats of fixed bit width
typedef unsigned int uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;
// define uint64 type
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
typedef unsigned __int64 uint64;
#else
typedef unsigned long long uint64;
#endif


}

#endif

Detalle:

Esta clase es de vital importancia al momento de compilar Ogre3D ya que le indica todo, datos como sobre que Sistema Operativo sobre el que está trabajando, Arquitectura, compilador y versión del mismo, etc., debido a esto, esta clase es VITAL para todos los proyectos que uno va a desarrollar, yo recomiendo bastante utilizar esta clase para esta labor y para cualquier proyecto.

Iniciamos:

Línea 29 - 30:
--
#ifndef __Platform_H_
#define __Platform_H_
--

Declaración de cabecera

Línea 32:
--
#include "OgreConfig.h"
--

Se incluye el archivo OgreConfig.h que analizamos antes.

Línea 34:
--
namespace Ogre {
--

Se hace la declaración del namespace (o paquete) Ogre.

Línea 37 - 39:
--
#define OGRE_PLATFORM_WIN32 1
#define OGRE_PLATFORM_LINUX 2
#define OGRE_PLATFORM_APPLE 3
--

Se definen las plataformas sobre las cuales compila y corre Ogre perfectamente (Windows, Linux, Mac)

Línea 41 - 43:
--
#define OGRE_COMPILER_MSVC 1
#define OGRE_COMPILER_GNUC 2
#define OGRE_COMPILER_BORL 3
--

Se definen los compiladores sobre los cuales se sabe que compila Ogre sin problemas, esto puede aumentar según la herramienta que se elija para esta tarea (la compilación)

Línea 45 - 46:
--
#define OGRE_ENDIAN_LITTLE 1
#define OGRE_ENDIAN_BIG 2
--

Orden en que se guardaran los datos.

Línea 48 - 49:
--
#define OGRE_ARCHITECTURE_32 1
#define OGRE_ARCHITECTURE_64 2
--

Arquitectura sobre la cual compila y corre el sistema (32 o 64 bits)

Línea 53 - 70:
--
#if defined( _MSC_VER )
# define OGRE_COMPILER OGRE_COMPILER_MSVC
# define OGRE_COMP_VER _MSC_VER

#elif defined( __GNUC__ )
# define OGRE_COMPILER OGRE_COMPILER_GNUC
# define OGRE_COMP_VER (((__GNUC__)*100) + \
(__GNUC_MINOR__*10) + \
__GNUC_PATCHLEVEL__)

#elif defined( __BORLANDC__ )
# define OGRE_COMPILER OGRE_COMPILER_BORL
# define OGRE_COMP_VER __BCPLUSPLUS__
# define __FUNCTION__ __FUNC__
#else
# pragma error "No known compiler. Abort! Abort!"

#endif
--

Este fragmento de código identifica sobre que compilador se está trabajando. Para esto cada compilador define unas macros que son:

VS ==> _MSC_VER
GCC ==> __GNUC__
Borland ==> __BORLANDC__

Dependiendo de cual de esas esté definida se sabe que compilador se está utilizando. Los compiladores también definen su versión en otra macro así:

VS ==> _MSC_VER
GCC ==> [__GNUC__][__GNUC_MINOR__][__GNUC_PATCHLEVEL__]
Borland ==> __BCPLUSPLUS__

Para el GCC, al ser tres digitos, toca moverlos, el primero tres dos posiciones (*100), el segundo una (*10) y el tercero si se deja en su lubar, asi se forma el número de versión [xxx].

Al final si no es ninguno de ellos, simplemente se aborta y se muestra un mensaje de error que indica que el compilador no es conocido.

Línea 73 - 83:
--
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
# if OGRE_COMP_VER >= 1200
# define FORCEINLINE __forceinline
# endif
#elif defined(__MINGW32__)
# if !defined(FORCEINLINE)
# define FORCEINLINE __inline
# endif
#else
# define FORCEINLINE __inline
#endif
--

Simplemente declara la macro FORCEINLINE para que funcione en todas las plataformas, en el caso de utilizar el compilador de Microsoft y dependiendo de su versión, en lugar de "inline" o "__inline" se utiliza "__forceinline".

Línea 87 - 95:
--
#if defined( __WIN32__ ) || defined( _WIN32 )
# define OGRE_PLATFORM OGRE_PLATFORM_WIN32

#elif defined( __APPLE_CC__)
# define OGRE_PLATFORM OGRE_PLATFORM_APPLE

#else
# define OGRE_PLATFORM OGRE_PLATFORM_LINUX
#endif
--

Este fragmento encuentra sobre que O.S. estamos trabajando, teniendo en cuenta las macros que definen los Sistemas así:

Windows ==> __WIN32__ ó _WIN32
Mac ==> __APPLE_CC__
Por descarte es Linux.

Se encuentra la plataforma y se almacena en la macro OGRE_PLATFORM, esto será de utilidad al momento de compilar cuando se utilizan llamadas que dependen del sistema como por ejemplo la carga dinámica de Plugins (dll's o so's).

Línea 98 - 102:
--
#if defined(__x86_64__) || defined(_M_X64) || defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || defined(__s390x__)
# define OGRE_ARCH_TYPE OGRE_ARCHITECTURE_64
#else
# define OGRE_ARCH_TYPE OGRE_ARCHITECTURE_32
#endif
--

Encuentra la arquitectura sobre la cual se está trabajando, si es de 32 o de 64 bits, esto viene definido en macros del hardware que tenemos así:

64 bits: __x86_64__, _M_X64, __powerpc64__, __alpha__, __ia64__, __s390__, __s390x__
32 bits: por descarte

Línea 107 - 109:
--
#define OGRE_QUOTE_INPLACE(x) # x
#define OGRE_QUOTE(x) OGRE_QUOTE_INPLACE(x)
#define OGRE_WARN( x ) message( __FILE__ "(" QUOTE( __LINE__ ) ") : " x "\n" )
--

Define algunas macros para los mensajes mostrados en la salida del compilador que indican el archivo y la línea, además del error encontrado.

Línea 113:
--
#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
--

Inicia algunas configuraciones para Windows, lo que viene debajo hasta el proximo "#endif" solo se compilará si estás en un windows.

Línea 117:
--
# if defined( OGRE_STATIC_LIB )
--

Verifica si se está trabajando con Ogre como una lib estática, en caso acertado compila lo que sigue.

Línea 119 - 132:
--
# define _OgreExport
# define _OgrePrivate
# else
# if defined( OGRE_NONCLIENT_BUILD )
# define _OgreExport __declspec( dllexport )
# else
# if defined( __MINGW32__ )
# define _OgreExport
# else
# define _OgreExport __declspec( dllimport )
# endif
# endif
# define _OgrePrivate
# endif
--

Verifica con que directiva debe exportar los símbolos (clases, objetos, estructuras y todo lo demás de Ogre), si es estática simplemente realiza una declaración y ya está, si es dinámica (dll en windows), se utiliza "__declspec( dllexport )" (en Mac también), de esta manera al compilar se incluye las clases que tengan antes de su nombre la palabra "_OgreExport" en la lista de símbolos de la dll para poder ser usadas desde programas externos que enlacen la dll de Ogre (o so).

Línea 134 - 138:
--
# ifdef _DEBUG
# define OGRE_DEBUG_MODE 1
# else
# define OGRE_DEBUG_MODE 0
# endif
--

Identifica si está en modo debug o release, en los compiladores de Windows cuando se trabaja en Debug se introduce al compilar la macro "_DEBUG", con esto es posible saber si se está compilando en Debug o en Release en windows.

Línea 143 - 152:
--
#if defined( __MINGW32__ ) && !defined(_STLPORT_VERSION)
# include<_mingw.h>
# if defined(__MINGW32_TOOLBOX_UNICODE__)
# define OGRE_UNICODE_SUPPORT 1
# else
# define OGRE_UNICODE_SUPPORT 0
# endif
#else
# define OGRE_UNICODE_SUPPORT 1
#endif
--

Verifica con que se está compilando y según sea, habilita o no el soporte para Unicode, ya que en MingW es muy pobre, si estas en Windows con Visual Studio se activa el soporte para unicode.

Línea 154:
--
#endif
--

Termina la configuración de Windows.

Línea 159:
--

#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_APPLE

--

Inicia la configuración de Mac y Linux

Línea 162 - 168:
--
# if defined( OGRE_GCC_VISIBILITY )
# define _OgreExport __attribute__ ((visibility("default")))
# define _OgrePrivate __attribute__ ((visibility("hidden")))
# else
# define _OgreExport
# define _OgrePrivate
# endif
--

Directivas de exportación de símbolos, equivalente al de Windows.

Línea 171:
--
# define stricmp strcasecmp
--

Simplemente define un nuevo nombre para una funcion, para manejar todo igual en el código.

Línea 177 - 181:
--
# ifdef DEBUG
# define OGRE_DEBUG_MODE 1
# else
# define OGRE_DEBUG_MODE 0
# endif
--

Mira si se está ejecutando en modo debug o release, en Linux lo que se hace es que se añade una flag al comando gcc para indicar que se está compilando en modo debug.

Línea 192:
--
#define OGRE_UNICODE_SUPPORT 1
--

Habilita el soporte para unicode que no tiene problemas ni en linux ni en Mac en versiones actuales del compilador.

Línea 194:
--
#endif
--

Termina la configuración del Linux y Mac.

Línea 197 - 199:
--
#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE
# include "config.h"
#endif
--

En Apple (Mac) se tiene un archivo de configuración de proyecto independiente, lo que hace es incluirlo.

Línea 206 - 210:
--
#ifdef OGRE_CONFIG_BIG_ENDIAN
# define OGRE_ENDIAN OGRE_ENDIAN_BIG
#else
# define OGRE_ENDIAN OGRE_ENDIAN_LITTLE
#endif
--

Asigna el Endian correctamente en Ogre según se trabaje en la plataforma sobre la cual se está compilando, a Little o Big.

Línea 213 - 215:
--
typedef unsigned int uint32;
typedef unsigned short uint16;
typedef unsigned char uint8;
--

Crea los tipos de entero uint32, uint16 y uint8 según se ve en la definición.

Línea 217 - 221:
--
#if OGRE_COMPILER == OGRE_COMPILER_MSVC
typedef unsigned __int64 uint64;
#else
typedef unsigned long long uint64;
#endif
--

Identifica sobre que compilador se está trabajando para crear el tipo de entero uint64; si es en Visual Studio el tipo original es __int64, pero si es en otro compilador (como gcc o mingw) es "long long", ambos sin signo.

Línea 224 - 226:
--
}

#endif
--

Cierra la declaración del namespace (paquete) Ogre y termina la declaración de la clase.

Bueno espero que esta explicación sea de ayuda, sobre todo por que esta misma información sin cambios es muy útil para cualquier tipo de proyecto que tenga dentro de sus features la portabilidad entre plataformas.

Proxima entrada OgrePrerequisites.h

Nos vemos

El corazón del Ogro: OgreConfig.h

2009-01-07T07:36:00.000-08:00

En este momento estoy en proceso de desacoplar el Ogre 3D Engine en varios componentes, uno de ellos se llama "Ogre_Core", por esta razón he tenido que releer las fuentes y pues pensé que sería bueno ir colocando aca el análisis de cada clase que vaya mirando.

Hoy iniciaré con:

OgreConfig.h

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2006 Torus Knot Software Ltd
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple

Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.

You may alternatively use this source under the terms of a specific version of
the OGRE Unrestricted License provided you have obtained such a license from
Torus Knot Software Ltd.
-----------------------------------------------------------------------------
*/
#ifndef __Config_H_
#define __Config_H_

// Read configuration options; some systems use an auto-generated config.h,
// other use a manually generated config.h; in any case just define
// HAVE_CONFIG_H to include the custom config.h file.
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

/** If set to 1, profiling code will be included in the application. When you
are deploying your application you will probably want to set this to 0 */
#define OGRE_PROFILING 0

/** There are three modes for handling asserts in OGRE:
0 - STANDARD - Standard asserts in debug builds, nothing in release builds
1 - RELEASE_EXCEPTIONS - Standard asserts in debug builds, exceptions in release builds
2 - EXCEPTIONS - Exceptions in debug builds, exceptions in release builds
*/
#define OGRE_ASSERT_MODE 0

/** If set to >0, OGRE will always 'think' that the graphics card only has the
number of texture units specified. Very useful for testing multipass fallback.
*/
#define OGRE_PRETEND_TEXTURE_UNITS 0

/** If set to 1, Real is typedef'ed to double. Otherwise, Real is typedef'ed
to float. Setting this allows you to perform mathematical operations in the
CPU (Quaternion, Vector3 etc) with more precision, but bear in mind that the
GPU still operates in single-precision mode.
*/
#ifndef OGRE_DOUBLE_PRECISION
#define OGRE_DOUBLE_PRECISION 0
#endif

/** Define number of texture coordinate sets allowed per vertex.
*/
#define OGRE_MAX_TEXTURE_COORD_SETS 6

/** Define max number of texture layers allowed per pass on any card.
*/
#define OGRE_MAX_TEXTURE_LAYERS 16

/** Define max number of lights allowed per pass.
*/
#define OGRE_MAX_SIMULTANEOUS_LIGHTS 8

/** Define max number of blending weights allowed per vertex.
*/
#define OGRE_MAX_BLEND_WEIGHTS 4

/** Define this if you want to link OGRE as a static lib (preferably as a project file)
*/
//#define OGRE_STATIC_LIB


// define the memory allocator configuration to use
#define OGRE_MEMORY_ALLOCATOR_STD 1
#define OGRE_MEMORY_ALLOCATOR_NED 2    // you need to have nedmalloc on your path for this
#define OGRE_MEMORY_ALLOCATOR_USER 3

#define OGRE_MEMORY_ALLOCATOR OGRE_MEMORY_ALLOCATOR_STD

// enable or disable the memory tracker, recording the memory allocations & tracking leaks
// default is to disable since it's expensive, but you can enable if needed per build target

#ifndef OGRE_MEMORY_TRACKER_DEBUG_MODE
#  define OGRE_MEMORY_TRACKER_DEBUG_MODE 0
#endif

#ifndef OGRE_MEMORY_TRACKER_RELEASE_MODE
#  define OGRE_MEMORY_TRACKER_RELEASE_MODE 0
#endif
/** Define max number of multiple render targets (MRTs) to render to at once.
*/
#define OGRE_MAX_MULTIPLE_RENDER_TARGETS 8

/** Support for multithreading, there are 3 options

OGRE_THREAD_SUPPORT = 0
No support for threading.
OGRE_THREAD_SUPPORT = 1
Thread support for background loading, by both loading and constructing resources
in a background thread. Resource management and SharedPtr handling becomes
thread-safe, and resources may be completely loaded in the background.
The places where threading is available are clearly
marked, you should assume state is NOT thread safe unless otherwise
stated in relation to this flag.
OGRE_THREAD_SUPPORT = 2
Thread support for background resource preparation. This means that resource
data can streamed into memory in the background, but the final resource
construction (including RenderSystem dependencies) is still done in the primary
thread. Has a lower synchronisation primitive overhead than full threading
while still allowing the major blocking aspects of resource management (I/O)
to be done in the background.
*/
#ifndef OGRE_THREAD_SUPPORT
#define OGRE_THREAD_SUPPORT 0
#endif
#if OGRE_THREAD_SUPPORT != 0 && OGRE_THREAD_SUPPORT != 1 && OGRE_THREAD_SUPPORT != 2
#define OGRE_THREAD_SUPPORT 1
#endif

/** Disables use of the FreeImage image library for loading images.
WARNING: Use only when you want to provide your own image loading code via codecs.
*/
#ifndef OGRE_NO_FREEIMAGE
#define OGRE_NO_FREEIMAGE 0
#endif

/** Disables use of the DevIL image library for loading images.
By default DevIL is disabled in Eihort in favour of FreeImage, but you may re-enable
it if you choose
*/
#ifndef OGRE_NO_DEVIL
#define OGRE_NO_DEVIL 1
#endif

/** Disables use of the internal image codec for loading DDS files.
WARNING: Use only when you want to provide your own image loading code via codecs.
*/
#ifndef OGRE_NO_DDS_CODEC
#define OGRE_NO_DDS_CODEC 0
#endif

/** Enables the use of the new script compilers when Ogre compiles resource scripts.
*/
#ifndef OGRE_USE_NEW_COMPILERS
#define OGRE_USE_NEW_COMPILERS 1
#endif

#endif

Detalle:

Esta es una de las primeras clases que carga Ogre al iniciar su funcionamiento, en ella Sinbad ha definido muchos parámetros para que el motor trabaje adecuadamente, pero todos estos pueden ser alterados según nuestros gustos y necesidades.

Las dos primeras líneas de código declaran la cabecera
--
#ifndef __Config_H_
#define __Config_H_
--

Luego tenemos:
--
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
--

En algunos IDEs o herramientas para proyectos se genera un archivo de configuración del mismo con datos como directivas de compilación, nivel de optimización, si es multihilo o no, entre otras opciones. Esto también es muy utilizado en caso de tener un proyecto grande, incluso manualmente uno lo hace para poner en este archivo todas las directivas de configuración necesarias para la compilación del proyecto, así que si deseas que se haga uso de este archivo en la compilación de Ogre (o proyecto usando Ogre), solo basta definir la macro HAVE_CONFIG_H.

Luego viene:
--
#define OGRE_PROFILING 0
--

Esto permite utilizar herramientas de analisis de optimización para saber donde y que optimizar, para habilitarlo en Ogre hay que definir esta macro a 1. Ten en cuenta la recomendación que hace Sinbad sobre esta declaración y es poner a 0 esta macro cuando vayas a entregar el producto, ya que hace mucho mas lento todo debido a ejecuciónes que necesita para podernos decir cierta información sobre memoria y tiempos de ejecución.

Línea 48:
--
#define OGRE_ASSERT_MODE 0
--

Como dice en el comentario, Ogre tiene 3 maneras de manejar las Asserciones, la primera es que solo se visualice en modo Debug la info y dejar limpio el modo Release (OGRE_ASSERT_MODE = 0), la segunda es que muestro todo en Debug y solo excepciones en Release (OGRE_ASSERT_MODE = 1) y la tercera es que muestre TODO tanto en Debug como en Release (OGRE_ASSERT_MODE = 2 ).

Línea 53:
--
#define OGRE_PRETEND_TEXTURE_UNITS 0
--

Esta flag le indica a Ogre que el hardware (Video) solo puede manejar esa cantidad de Texturas y (TMU), si lo dejas en 0 Ogre lo determina.

Línea 60 - 62:
--
#ifndef OGRE_DOUBLE_PRECISION
#define OGRE_DOUBLE_PRECISION 0
#endif
--

Por defecto en Ogre el tipo "Real" está definido como un float, pero si aca cambiamos el 0 por un 1, Ogre hará que este tipo sea un double. Diferencias: que el double tienes calculos matemáticos mucho mas precisos, pero también tienes costos en rendimiento ya que el hardware trabaja con floats (single - precision)

Línea 66:
--
#define OGRE_MAX_TEXTURE_COORD_SETS 6
--

Define el número máximo de conjutos de coordenadas de texturas por vértice, se puede acomodar según tu hardware (o el de tu público objetivo).

Línea 70:
--
#define OGRE_MAX_TEXTURE_LAYERS 16
--

Define el número máximo de texturas permitidas por pase sobre cualquier hardware

Línea 74:
--
#define OGRE_MAX_SIMULTANEOUS_LIGHTS 8
--

Define el número máximo de luces permitidas por pase.

Línea 82:
--
//#define OGRE_STATIC_LIB
--

Indica si deseamos utilizar Ogre3D como una lib estática (por defecto se debe usar como una lib dinámica)

Línea 86 - 88:
--
#define OGRE_MEMORY_ALLOCATOR_STD 1
#define OGRE_MEMORY_ALLOCATOR_NED 2
#define OGRE_MEMORY_ALLOCATOR_USER 3
--

Define que framework utilizar para el manejo de la memoria, asignación, liberación. El estandar es el de STD (estandar en C++), también soporta el de nedmalloc, que según se (no lo he usado) es muy bueno con aplicaciones multi-hilo que corren sobre varias CPUs y finalmente soporta el manejador que implemente cada usuario de Ogre, así que dependiendo de la necesidad puedes utilizar el estandar, para multiples hebras y cpu's o uno propio.

Línea 90:
--
#define OGRE_MEMORY_ALLOCATOR OGRE_MEMORY_ALLOCATOR_STD
--

Define el manejador a utilizar, por defecto será el estandar (STD), para utilizar otro solo basta cambiar el valor de asignación de esta flag, algo como:

--
#define OGRE_MEMORY_ALLOCATOR OGRE_MEMORY_ALLOCATOR_USER
--

Línea 95 - 101:
--
#ifndef OGRE_MEMORY_TRACKER_DEBUG_MODE
# define OGRE_MEMORY_TRACKER_DEBUG_MODE 0
#endif

#ifndef OGRE_MEMORY_TRACKER_RELEASE_MODE
# define OGRE_MEMORY_TRACKER_RELEASE_MODE 0
#endif
--

Esta flag permite trabajar con Ogre de manera que nos diga los desperdicios de memoria, y en general toda la información de memoria durante la ejecución de la aplicación, es muy útil para realizar trabajo de debug y optimización. Igual hay que recordar que esto es algo costoso a nivel computacional así que no debe dejarse habilitada (en caso de uso) en la versión release del producto.

Línea 104:
--
#define OGRE_MAX_MULTIPLE_RENDER_TARGETS 8
--

Define el número máximo de MRTs posibles.

Línea 125 - 130:
--
#ifndef OGRE_THREAD_SUPPORT
#define OGRE_THREAD_SUPPORT 0
#endif
#if OGRE_THREAD_SUPPORT != 0 && OGRE_THREAD_SUPPORT != 1 && OGRE_THREAD_SUPPORT != 2
#define OGRE_THREAD_SUPPORT 1
#endif
--

Estas opciones son para el soporte multi-hilo de Ogre. Aquí es posible utilizar 3 valores:

0 = No hay soporte para multi-hilo
1 = Un hilo para la carga y construcción en fondo de los recursos midia.
2 = Esta opción es para cargar los recursos en memoria en un hilo independiente (y en fondo) pero su construcción será realizada sobre el hilo principal .

Línea 135 - 137:
--
#ifndef OGRE_NO_FREEIMAGE
#define OGRE_NO_FREEIMAGE 0
#endif
--

Deshabilita el uso de FreeImage para realizar las operaciones de carga de imágenes, esta opción solo debe utilizarse cuando se tenga otra herramienta para realizar esta tarea (se pone a 1 este flag)

Línea 143 - 145:
--
#ifndef OGRE_NO_DEVIL
#define OGRE_NO_DEVIL 1
#endif
--

Deshabilita el uso de la lib DevIL para la carga de imágenes, esta era la que se utilizaba en Ogre hasta la versión Dagon (si mal no recuerdo) pero fue reemplazada por FreeImage. Igual puede volver a activarse si se desea (flag de freeimage a 0 y este a 1)

Linea 150 - 152:
--
#ifndef OGRE_NO_DDS_CODEC
#define OGRE_NO_DDS_CODEC 0
#endif
--

Deshabilita el uso del Codec interno de Ogre para cargar archivos en formato DDS, solo debe utilizarse si uno puede proveer otro codec.

Línea 156 - 158:
--
#ifndef OGRE_USE_NEW_COMPILERS
#define OGRE_USE_NEW_COMPILERS 1
#endif
--

Habilita el uso de un nuevo compilador de scripts para los scripts de Ogre, útil si tu escribes tu propio compilador o si extiendes el que ya existe para añadirle nuevas funcionalidades pero como una extensión del "por defecto" de Ogre.

Línea 160:
--
#endif
--

Termina la declaración del archivo.

Bueno este es el primer archivo de Ogre3D y su explicación en español, a este se le pueden añadir mas opciones o incluir un config.h en el proyecto y utilizarlo para definirlas.

El próximo será OgrePlatform.h donde se encuentra el código que permite determinar sobre que plataforma, O.S. y compilador estoy trabajando y define otras cositas mas.

Themes Gears of War y Assassins Creed

2009-01-06T14:44:00.000-08:00

Bueno renovando el look de mi blog (y eligiendo el del nuevo) me tope con estos dos themes que deseo hacer públicos para todos los video gamers amantes de Gears of War y/o de Assassins Creed para que los pongan en sus blogs

http://assassins-btemplates.blogspot.com/

http://gears-btemplates.blogspot.com/

Nuevo año, nueva imagen

2009-01-06T12:47:00.000-08:00

Como iniciamos un año nuevo toca renovar de todo, así que les presento el nuevo diseño del blog, mas organizado y con un nuevo gadget para que dejen el mensaje ¬¬.

También anuncio la publicación de un nuevo blog llamado Sucexos el cual ya está con el diseño y todo y espero iniciar a postear sobre él en esta semana, la cosa será que este blog lo voy a dejar para cosas netamente laborales y con relación a la tecnología, mientras que el otro blog (sucexos) será para todo lo demás.

Nos vemos pronto.

Adios año viejo de los infiernos

2008-12-31T16:22:00.000-08:00

jjejejeje Realmente este año ha tenido de todo, así que no sería un año del infierno, mas bien un año bien terrenal jejejeje. Ultimo post del año el último dia del año.

Bueno creo que estoy bastante agradecido por este año que ha terminado ya que me trajo resto de cosas hermosas, personas y experiencias: una hija maravillosa y hermosa que me llena de alegria y le da parte del sentido a cada dia. Una madre comprensiva y que jamas me retira su apoyo por mas que yo la cague y que sea como la mula :D; Amigos que afianzaron su amistad, que aunque me torne monotemático siguen ahí oyendo la misma historia una y otra vez :P, nuevos amigos como el costeño, que han mostrado ser personas interesantes (la mayoria ¬¬) pero finalmente todos amigos que apoyan cuando lo he necesitado y que no han sumado cargas al diario vivir y por el contrario ayudan a aliviar un poco las que yo he llevado.

También trajo consigo un portatil, un nuevo PC muy potente, nuevos títulos como Fallout 3, Prince of Persia, Dead Space, Mass Effect y Lost Planet entre otros. Trajo oportunidades nuevas de trabajo, de aprender nuevas cosas. Algunas decepciones laborales :'(, las malas noticias que nunca faltan pero que enseñan algo siempre, un nuevo IDE para Qt y versiones maduras de frameworks de trabajo como Ogre, QooxDoo y Symfony.

También trajo viajes, la oportunidad de conocer la costa, Cartagena, Islas del Rosario, Oceanario y sus animales acuáticos como los tiburones y las rayas. Comida que no conocia como las langostas y el cangrejo y otras mas.

En general fue un excelente año con sus por mayores y por menores.

Y ahora a darle la bienvenida al que llega, que viene lleno de muchas promesas y proyectos, proyecciones de automovil, estudiar idiomas, cursos complementarios a mi carrera en el SENA, oportunidades de viaje y de extrenar otro PC, nuevo proyecto de Colciencias también con 3D y propagación de redes móviles, reforma a Tribungo y tal vez oficina nueva entre otras tantas cosas espectaculares. Otros 364 dias mas para disfrutar de mi hija. Y finalmente nuevos títulos como Mirror's Edge, End War (PC), FEAR 2, Borderlands, Prototype entre otros.

mm y también dos consolas de Next-Gen XBox 360 y PS3 si todo sale como está planeado jejeje, como mensiono al inicio, año lleno de promesas, proyectos y buenas proyecciones.

FELIZ FIN DE AÑO E INICIO DE OTRO PARA TODOS (LOS POCOS PERO MUY IMPORTANTES) LECTORES DE ESTE BLOG, LOS MEJORES DESEOS PARA TODOS USTEDES DE MI PARTE Y QUE SE HAGAN REALIDAD TODOS SUS SUEÑOS Y PLANES PARA ESTE AÑO QUE INICIA Y QUE PLANTEA SER ALGO EMOCIONANTE.

Su anfitrión Juan Diego Uran Correa (a.k.a. valtovar)