Escenario ya en 3D con Blender

El escenario en este momento consta únicamente de la mansión la cual fue diseñada anteriormente en Inkscape. En el post anterior del escenario simplemente se mostró una imagen de la vista frontal de la mansión la cual era una simple muestra y fue coloreada muy superficialmente aunque la vista si fue hecha con exacta perspectiva.

Pero lo que no fue mostrado en el post anterior fueron los planos de la mansión los cuales fueron importados en blender gracias a un Add-on que ya viene con el programa el cual nos permite importar archivos .SVG en blender y utilizarlos fácilmente debido a que en Blender aparecen como curvas editables.

No voy a explicar en este post la forma de importar .SVG ya que es muy sencillo, lo que sí quiero dar a entender es que el utilizar Inkscape y Blender en conjunto nos facilita muchos las cosas. En este post lo que quiero mostrar es el escenario ya construido  en 3D que ahora es únicamente el modelo ya que el texturizado e iluminación se harán más adelante.

En la creación del modelo hubo cambios con respecto a los planos hechos en Inkscape ya que al ver los volúmenes en 3D muchas veces se necesita agregar o quitar piezas ya que se tiene un concepto más claro de lo que se quiere, lógicamente aquí tenemos la ventaja que es un modelo para juegos y por lo tanto podemos ampliar la superficie cuanto queramos (eso si guardando las proporciones y claro esta si el terreno no ha sido hecho y limitado con anterioridad).

El modelo esta hecho en mallas separadas aunque en el mismo objeto esto se debe a la facilidad de manejo y también pensando en posteriores etapas, ya que si todo esta unido la etapa de texturizado se nos haría muy difícil aunque sea posible poner infinitas texturas en una misma malla y finalmente también tendríamos problemas con los engines ya que estos no permiten ilimitadas texturas.

Siempre tener en cuenta que cuando se crea personajes es mejor tenerlos en una misma malla ya que nos facilita la animación y la texturización no es tan complicada pero en cuanto a un escenario así sea una casa pequeña es mejor tenerla separada en varias mallas.

Ahora si los render del modelo en 3D.

Un vídeo para ver mejor el modelo.

Nota1: Los planos se pueden hacer directamente en blender, pero como inicie de un concepto este es preferible crearlo en Inkscape.

Nota2: Puede ser creada una sola malla para toda la construcción base y luego separar con la herramienta separate de Blender si es necesario.

Nota3: Es muy útil en la creación de edificaciones utilizar el Add-on para medir que ya viene con blender llamado Measure Panel el cual únicamente hay que activarlo.

Este ha sido el ultimo post del año.
hasta el próximo año!.

Luzath en 3D con Blender

En este post simplemente expongo al nuevo personaje ya diseñado en 3d con Blender 2.6, ahora se tomaron como referencia las imágenes hechas anteriormente del personaje.

A algunas partes del la ropa se les asigno simulación de cloth la cual nos proporciona Blender para que de esta manera la ropa sea más realista.

Como se podrán dar cuenta en las imágenes del modelo aun falta texturizar lo cual se hará mas adelante, ahora simplemente se da una muestra de lo que es el modelo.

Este modelo esta en alta resolución de esta manera es útil para hacer cortos animados pero introducirlo en un juego seria simplemente imposible por el numero de polígonos, por lo cual será necesario crear la retopología del modelo en uno de mucho menor número de polígonos y luego asignarle diferentes tipos de mapas para que se aproxime a un modelo bien definido.

Nota: aun falta dar vida a los ojos. Esta parte se hará cuando se este en el proceso de texturizado.

En seguida las imágenes:

La siguiente imagen es un render sin simulación cloth.

En la siguiente imagen se pueden ver las arrugas en la ropa generadas por la simulación cloth.

Igual que la anterior pero desde otro punto.

Finalmente las ultimas desde distinta perspectiva en las cuales nuestro personaje se a bajado la capucha.

Ahora de frente

Eso es todo!

Muy pronto primer escenario en 3d.

Escenario creado en Inkscape

En la siguiente imagen se muestra el primer escenario el cual es una mansión enorme, esta imagen fue hecha y pintada en inkscape siendo muy util la grilla de este programa, también se realizaron los planos para luego ser exportados a blender y de esta madera modelar el escenario en 3d.

Esta imagen es sencillamente un concepto de lo que sera el escenario, muchos detalles serán agregados al modelo 3d.

Esto es todo.

Personaje pintado en Mypaint

En seguida esta la imagen del personaje luzath ahora pintado en el programa mypaint, este permite crear dibujos libremente por lo cual requiere más trabajo para que los dibujos queden bien, este programa es muy útil para plasmar las ideas en figuras y por lo tanto es ideal para crear conceptos.

Ahora la imagen en la cual Luzath fue pintado con diferentes colores a lo hecho anteriormente con el programa Inkscape.

Eso es todo, próximamente Luzath en 3d!

Personaje hecho en Inkscape

Este es un nuevo personaje su nombre es luzath, el es una especie de monje pero con habilidades especiales.

Para realizar el personaje primero realice el concepto en papel y después lo diseñe con el programa Inkscape el cual permitió crear las hojas de personaje para próximamente ser modelado en blender. Ademas utilice gimp para realizar pequeños retoques.

En seguida esta la imagen del personaje diseñado y pintado en Inkscape.

Luzath

En el próximo post mostrare al mismo personaje pintado en el programa Mypaint. 

Y listo un nuevo personaje!

Ahora en el mundo físico de UDK

En el siguiente vídeo se muestra una escena similar a la vista en Ogre3D y bullet pero ahora con el engine UDK el cual utiliza el motor de físicas physx de Nvidia.

En este vídeo se sitúa de igual manera la puerta sustentada por un constraint RB_PrismaticActor que únicamente permite el movimiento de esta en el eje x del mundo. También se sitúan en esta escena dos esferas Softbody para interactuar y por último las cajas rigidbody.

Todas las formas de colisiones para los objetos static mesh son creadas en blender y exportadas a UDK. El exportador es realmente muy bueno y se puede encontrar en la siguiente página:

http://campagnini.net/

Se recomienda para exportar tener muy bien hechas las mallas y además situar bien las normales de todas las caras para luego en blender generar la triangulación con ctrl+T ya que el exportador suele dar problemas con esto y nos deforma las mallas, lógicamente al exportar desactivar la opción para triangular. Del resto seguir las instrucciones que se en encuentran con el addon.

Nota: siempre crear una malla de respaldo sin triangular antes de exportar debido a los problemas que el exportador pueda ocasionar, por ejemplo por una mala dirección de las normales.

Nota2: En este video todo lo hecho se hizo con físicas ya que esa era la idea, no se utilizo matinee para realizar la apertura y cierre de la puerta como se ve en los tutoriales de UDK sino que simplemente se utilizo físicas siendo la puerta un KActor. 

Ahora si el vídeo!

y listo

Bullet Physics y Ogre3d

En el siguiente vídeo muestro un pequeño escenario de prueba en el cual ya se encuentran añadidas las físicas y colisiones gracias a Bullet Physics y utilizando como motor gráfico Ogre3D. Para esto no se utilizo ningún wrapper como OgreBullet sino que se enlazo Bullet a Ogre3D directamente.

En el vídeo se muestran levemente objetos de colisión estaticos como las escaleras en la cual la forma de colisión fue hecha directamente en blender ya que blender usa Bullet esto es muy sencillo, después esta forma de colisión fue importada como un archivo .bullet en la aplicación. En otras shapes como en la pequeña muralla que soporta la puerta se utilizo formas compuestas de colisión.

En el vídeo se muestra como el personaje interactúa con objetos dinámicos como la caja siendo esta un rigibody y con una pelota la cual es un softbody.

Nuestro personaje por el momento solo tiene una capsula como su forma de colisión lo cual lo hace poco flexible, lo ideal es que la forma este ajustada al personaje y que cada parte cambie de acuerdo a la animación del mismo.

Para la puerta se utilizo un trigger el cual nos detecta cuando un objeto de colisión esta cerca para abrir la puerta  y nos detecta cuando el objeto esta saliendo del trigger para cerrar la puerta. En cuanto a la puerta ya que es un rigidbody dinámico en ella también aparecen las mismas fuerzas que en cualquier otro objeto por lo que si no la ajustamos a algo fijo esta puerta simplemente se caerá debido a su forma, Por esto se utilizo un slider constraint el cual nos permite ajustar la puerta a un movimiento lineal.

Y aquí esta el vídeo!

Instalar Bullet Physics para Codeblocks

1. Bajar la última versión de bullet en:

http://code.google.com/p/bullet/downloads/list

En mi caso bullet2.79.


2. Descomprimir Bullet preferiblemente en una carpeta de ruta corta, yo cree una carpeta en C:\Bulletcodeblocks
La ruta para bullet quedo C:\Bulletcodeblocks\bullet 2.79
Bajar CMake de:
http://www.cmake.org/cmake/resources/software.html la versión que yo tengo es CMake 2.8.5

3. Poner en las variables de entorno en path minGW/bin con la version de minGW que se quiera compilar, en mi caso configure el path para minGW 32 bits por problemas con las versión de bullet 2.78 para compilar en 64bits. 

Nota: En el siguiente paso es importante lo del punto 3 debido a que Cmake se configura de acuerdo a esto y nos ahorra el tener que hacerlo a mano.


4. Configuración Cmake

Despues de instalar Cmake abrir CMake-gui

•     where is the source code: En mi caso C:\Bulletcodeblocks\bullet 2.7
•     Where to build the binaries: en mi caso C:\Bulletcodeblocks

Dar en configure, saldrá otra ventana donde debemos poner el compilador en nuestro caso codeblocks 
minGW y dejar el radio button en Use default native compilers. Después habrá errores debido a que no esta
completamente configurado.  “Los errores aparecen en rojo”.

Es necesario chekear advanced para que salgan el resto de opciones y también chekear grouped para mayor orden.


pestaña BUILD:

Se checkea los demos que se quieran construir pero hay que tener cuidado en tener instalado antes lo que se requiere por ejemplo para nvidia opencl demos tener ya instalado Cuda. 
Si se chekea build opencl demos es necesario tener opencl ya sea para Nvidia o para intel  instalado. En el caso de chekear para nvidia configurar como sigue:

• Nvidia Opencl_ICD_CFG colocar la ruta C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v4.0/lib/Win32
• Nvidia Opencl_INCLUDES C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v4.0/include/CL
• libraries C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v4.0\lib\Win32\Opencl.lib.

Pestaña Cmake:
Ya estara todo configurado si se puso minGW/bin en el path. Unicamente en:

• Cmake_Codeblocks_executable poner la ruta de codeblocks. 

Pestaña GLUT:
Si se checkea Los Demos y extras es necesario configurar la ruta de glut y checkear glut, aquí simplemente poner las rutas a las librerías de glut. Ojo, bullet trae una carpeta llamada Glut por lo tanto sacar las librerías y headers de aquí y copiarlas en minGW y configurar las ruta de mingw, también son necesarias las librerias glew.lib así que copiarlas tambien , después borra la carpeta ya que si se deja compilara con errores en esta carpeta.


Pestaña NVIDIA:

Si se chekea build opencl demos es necesario tener opencl ya sea para Nvidia o para intel  instalado. En el caso de chekear para nvidia configurar como sigue:

• Nvidia Opencl_ICD_CFG colocar la ruta C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v4.0/lib/Win32
• Nvidia Opencl_INCLUDES C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v4.0/include/CL
• libraries C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v4.0\lib\Win32\Opencl.lib.
• Para intel hacer algo parecido pero con el sdk de Intel.

Pestaña USE

Si se quiere se puede chekear  Use_custom_Vector_Math, esto no es indispensable pero si se checkea estar seguro que se escoge la ruta: C:/Bulletcodeblocks/bullet-2.79/src/vectormath/scalar ya que sse genera errores en la compilación. esta ruta puede ser cambiada en la pestaña Ungrouped entries.
¿Utilizar o no utilizar doble precisión?
Yo creo que los computadores de nuestro tiempo ya son lo suficientemente adelantados como para utilizar doublés pero si se quiere crear un juego o aplicación para un teléfono u otro dispositivo  es necesario utilizar floats.
Finalmente Chekear use glut y graphical_Benchmark.
Por ultimo presionar Configure y si ya no hay nada en rojo podemos proceder a dar en Generate.
A continuación las imágenes para mayor comprensión:

5. Construyendo el proyecto

•  Ahora ir a la carpeta en mi caso C:\Bulletcodeblocks\ y abrir el archivo .cbp. se abrirá codeblocks con el proyecto.
• Si le damos en build nos compilara el proyecto pero si aparece nada para compilar entonces debemos configurar el compilador. El problema se debe a que muchas veces nosotros tenemos mingw32-g++.exe  en codeblocks y   g++.exe en las opciones de CMake. No cambiar la opciones de CMake, cambiar las opciones de Codeblocks y poner g++.exe en vez de mingw32-g++.exe  y asi con todos los demás para que la configuración de Codeblocks coincida con la de CMake.
• Le damos build y listo. No debe aparecer ningún error si se elimino la carpeta de Glut de bullet.
• Puede haber un error si se configuro con Use_custom _math _vector en cmake. Cambiar la linea 8 de C:\Bulletcodeblocks\bullet\src\vectormath\vmInclude.h por: #include "scalar/vectormath_aos.h".
• Si le dimos que compile los demos de opencl estos no apareceran compilados debido a que no encontraron la libreria glew32.lib o glew34.lib esto se debe a que eliminamos la carpeta glut. Pero el haber eliminado la carpeta no esta mal ya que de igual manera al enlazar con glew32.lib nos genera errores.
• Para solucionar el problema debemos enlazar con glew32.dll para esto debemos
• abrir el archivo C:\Bulletcodeblocks\Demos\ParticlesOpenCL\NVidia\CMakeFiles\AppParticlesOCL_Nv.dir\link.txt
• Poner C:\Bulletcodeblocks\bullet-2.79\glew32.dll después de ..\lib\libLinearMath.a y eliminar la ruta anterior que se enlazaba a la carpeta glut\glew32.lib.
• Por ultimo construir en codeblocks unicamente para appParticlesOCL_Nv hay que hacer esto con cada demo que no se construyo, seguramente porque utilizan glew. Ojo se puede construir cada demo no es nesesario darle bulild a todo el proyecto.

6. Probando bullet
Copiar el ejemplo de getting started de la wiki de la pagina web de bullet.
en un nuevo proyecto bullet es necesario poner la definición  en la pestaña compiler settings -> #defines poner BT_USE_DOUBLE_PRECISION si se construyeron las librerías para que funcionen con doble precisión. Si todo funciona correcto ya podemos trabajar con bullet.
No olvidar enlazar las librerías creadas, pero tomar atención al orden sin no no enlazara bien el programa.

• libBulletWorldImporter.a (opcional)
• libBulletFileLoader.a (opcional)
• libBulletMultiThreaded.a (opcional)
• libBulletSoftBody.a (opcional)
• libBulletDynamics.a
• libBulletCollision.a
• libLinearMath.a

el orden de enlazar es importante por ejemplo si enlazan bulletFileLoader en la parte superior bulletWorldImporter no funcionara debido a que necesita de bulletFileLoader.

Y listo a programar con física!

Humanoide corriendo en UDK

Ahora si el humanoide se muestra en el siguiente vídeo corriendo en el engine Unreal Develpment Kit.

Ahora el humanoide ya corre en UDK.

Exportando animación de blender a UDK

En este post explicare de una manera sencilla como exportar un skeletal mesh o modelo animado a Unreal Development Kit.

1. Activar el Add-on que viene ya preinstalado con blender 2.59 como se muestra en la siguiente imagen

2.Crear la animación en el action editor y al exportar tener abierta la animación que se necesita. También se puede exportar todas las animaciones checkeando all en el exportador.

3.Es importante que tanto la armature como la mesh estén centrados en el punto (0,0,0) también es importante que entes escalados en (1,1,1). Las escalas deben corresponder, si es necesario cambiar el tamaño de la mesh en edit mode.

4. Como en el exportador de ogre también es necesario que máximo 4 huesos afecten un vértice, ademas es importante saber que no se puede exportar un armature con un único hueso.

5. para exportar se activan las casillas de lo que se quiere exportar sea animación(.psa) o únicamente el skeletal mesh(.psk). 

6. En UDK simplemente importar el archivo .psk en el content browser.

7. Para cargar las animaciones en UDK es necesario crear un animset. Para crear un animset dar click derecho en el content browser y escoger new animset.

Para importar dar en el animset file y import psa.

Y listo.

Humanoide caminando en Ogre3D

Ahora coloco un vídeo en el cual se muestra al humanoide caminando en el engine Ogre3D. En la primera parte del vídeo aparece el render hecho en blender, en la segunda y tercera parte aparece el humanoide en ogre3D caminando a distintas velocidades.

Nota: en el cambio de velocidad se hizo necesario cambiar la velocidad de la animación en blender para que coincida con la traslación en Ogre.

A continuación el vídeo:

El humanoide aprendió a caminar!.

Exportando animación de blender a Ogre3D

Para exportar las mallas, el sistema de huesos y las animaciones utilizo el plugin que se puede bajar de aquí:

http://code.google.com/p/blender2ogre/

Antes de instalar el plugin es necesario bajar OgreCommandLineTools que se puede encontrar en la pagina de Ogre3D ya que estos ejecutables nos transforman los archivos xml que produce el exportador a archivos .mesh, .material, .skeleton necesarios en Ogre.

Primero instalar OgreCommandLineTools y luego el plugin los reconocerá automáticamente.

Este plugin hay que adicionarlo a blender, para hacer esto se descomprime el archivo y se copia el archivo con extensión .py en la carpeta addons de blender, para encontrar esta carpeta en windows se debe habilitar ver archivos ocultos del sistema y luego entrar a la siguiente ruta según el usuario y la versión de blender.

RUTA: C:\usuarios->nombreusuario->AppData->Roaming->Blender Foundation->Blender->version->scripts->addons

Después de copiar el archivo simplemente se habré blender, luego se presiona en user preferences y en la pestaña Add-Ons buscar Ogre Exporter y despues se activa el cuadro que esta al frente del nombre en el cual debe aparecer una marca de verificación.

Para que la animación hecha en blender pueda se exportada correctamente a ogre 3D es necesario lo siguiente:

1. Lo usual para crear una animación es crear huesos de deformación y otros de control, la animación se suele hacer rotando, escalando y moviendo estos huesos de control y lógicamente insertando sus respectivas keyframes. Pero si exportamos la animación de la manera anterior esta no funcionara en ogre ya que ogre solo utiliza los huesos de deformación por lo que cuando se inserte una keyframe del hueso de control se hace necesario hacer lo mismo con los huesos de deformación que se utilicen.

2. Es necesario que la rotación de la armature este en el mismo valor que la rotación de la mesh esto se ve en el panel de propiedades que se abre presionando N.

3. Si se tiene algún problema en la animación es necesario rotar la mesh con respecto a la armature para que coincida en Ogre3D.

4. Máximo cuatro huesos de deformación pueden estar asociados a un vertex si no es así cambiar los valores de weight a cero en los vértices que sobrepasen este limite.

5. Se requiere abrir el NLA editor y allí crear el strip respectivo a la acción, se cambia el nombre en el panel de propiedades presionando N en el NLA editor y se cambia el nombre en Active Track, ojo este sera el nombre que necesitaremos para llamar a la acción en Ogre.

Para Exportar se selecciona la mesh y la armature, despues se activan la opciones como se ve en la imagen:

Muchas veces no coincide la animación con la mesh en Ogre y puede generar mala animación como se ve en la siguiente imagen:

Para arreglar lo anterior es necesario rotar la mesh con respecto a la armature hasta que coincida en Ogre.
En la siguiente imagen se explica de una manera visual algunos puntos anteriores.

Esto es todo, en el próximo post mostrare al humanoide caminando en Ogre3D.

Humanoide con esqueleto y posando

En las siguientes imágenes se encuentra el modelo humanoide con su esqueleto bien definido en la ventana de blender 2.59.

En los cuadros de abajo se presentan algunas poses hechas rápidamente con el esqueleto asignado, hay algunos errores en los hombros eso debido a que falta aun este par de huesos y algunos pivotes también.

De aquí en adelante a realizar animaciones para que sean asignadas en los engines que se quiera. Hay una excelente pagina con excelentes tutoriales, la cual me parece muy buena por eso, dejo el link abajo.

www.blendercookie.com/

Humanoide en Ogre3D

Ahora pongo un vídeo y una fotos desde distintos lugares de el modelo humanoide en el motor Ogre 3D.
Para el bump mapping se usan shaders creados en CG.

Enseguida el vídeo:

Algunas Fotos:

Esto es todo, próximamente humanoide animado.

Ejecutando y compilando programas CG

En este post coloco el código para ejecutar el sencillo ejemplo de cambiar el color.
Para comenzar creamos un widget que contenga opengl.
El header es:

#ifndef QGLWIDGET_H_INCLUDED
#define QGLWIDGET_H_INCLUDED
#include <QtOpenGL/QGLWidget>
#include <Cg/cg.h>
#include <Cg/cgGL.h>


class Glwidget : public QGLWidget     //hereda de QGLwidget
{
    public:
    Glwidget(QWidget *parent=0);
    ~Glwidget();
    protected:
   //funciones a sobrescribir de opengl
    void initializeGL();
    void paintGL();
    void resizeGL(int,int);
    private:
    //Miembros de CG
    CGcontext contexto;
    CGprofile perfil;   //para crear el perfil dependiendo de la api y la gpu
    CGparameter modelViewMatrix;  //parámetro para ingresar
    CGprogram programa;
};

Ahora el archivo cpp. qglwidget.cpp es:

#include <QtGui>
#include "qglwidget.h"
#include <iostream>
//Estos includes siguientes son necesarios para utilizar code-completion de codeblocks sin problemas
#include <GL/gl.h>
#include <GL/glu.h>


//función para el manejador de errores
void MyErrorHandler(CGcontext contexto, CGerror error, void *data) {
    CGcontext alf=cgCreateContext();
    if(contexto!=NULL){//para arreglar un problema de salida del programa
    alf=contexto;}
    const char *lastListing = cgGetLastListing(alf);
    qDebug() << (lastListing == 0 ? "No error." : lastListing);
}


Glwidget::Glwidget(QWidget *parent){};
Glwidget::~Glwidget(){
    cgDestroyProgram(programa);
    cgDestroyContext(contexto);
    cgDestroyParameter(modelViewMatrix);
}


void Glwidget::initializeGL(){
    contexto=cgCreateContext();
  //Creamos un manejador de errores con la función MyErrorHandler es muy útil utilizarlo para 
   // encontrar los errores facilmente en el archivo CG.
    cgSetErrorHandler(MyErrorHandler,NULL);
    //Se crea el perfil a partir de la ultima versión soportada por nuestra GPU.
    //Este es simplemente un Vertex shader, para hacer shaders mas realistas es necesario
    //utilizar también pixel shaders y para eso poner CG_GL_FRAGMENT
    perfil= cgGLGetLatestProfile(CG_GL_VERTEX);
    cgGLSetOptimalOptions(perfil);
//mi archivo cg se llama simplemente red.cg únicamente cambia el color del polígono.
//mainv es la función principal en nuestro programa.
    programa = cgCreateProgramFromFile(contexto,CG_SOURCE,"red.cg",perfil,"mainv",NULL);
    cgGLLoadProgram(programa);
    //Relacionamos nuestro parámetro a la variable literalmente de nuestro programa en cg
    modelViewMatrix = cgGetNamedParameter(programa, "ModelViewProj");
    glShadeModel(GL_SMOOTH); 
    glClearColor(0.0,0.0,0.0,0.0);
    glClearDepth(1.0f); // Depth buffer setup
    glEnable(GL_DEPTH_TEST); 
    glDepthFunc(GL_LEQUAL); 
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // R
}
void Glwidget::resizeGL(int width,int height){
    if (height == 0)
        height = 1;
    glViewport(0, 0, width, height); // Reset current viewport
    glMatrixMode(GL_PROJECTION); // Select projection matrix
    glLoadIdentity(); // Reset projection matrix
    gluPerspective (45.0f, (GLfloat)(width)/(GLfloat)(height),0.1f, 100.0f); // Calculate The Aspect Ratio
    glMatrixMode(GL_MODELVIEW); // Select modelview matrix
}
void Glwidget::paintGL(){
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
     glLoadIdentity(); 
     //las transformaciones siempre antes de aplicar el shader
     glTranslatef(0.0f, 0.0f, -5.0f);
    //ingresar nuestra matriz de proyección.
     cgGLSetStateMatrixParameter(modelViewMatrix, CG_GL_MODELVIEW_PROJECTION_MATRIX,        CG_GL_MATRIX_IDENTITY);
      //activamos el perfil y el programa.
     cgGLEnableProfile(perfil);
     cgGLBindProgram(programa);
    //Hacemos un sencillo cuadrado
    glBegin(GL_QUADS); 
        glVertex2f(0.7f,  0.7f); 
        glVertex2f(0.7f, -0.7f); 
        glVertex2f(-0.7f, -0.7f); 
        glVertex2f(-0.7f, 0.7f); 
       glEnd(); 
       cgGLDisableProfile(perfil);
       glFlush ();
}

creamos una archivo main.cpp con el siguiente código:

#include <iostream>
#include "qglwidget.h"  //el widget creado
#include <QApplication>
using namespace std;


int main(int argc,char *argv[])
{
    QApplication app2(argc,argv);
    Glwidget wid;
    wid.show();
    return app2.exec();
}
De esta manera podemos utilizar nuestro shader creado con CG.

Un simple programa en CG

En este post pongo el codigo de un sencillo programa en cg llamado red.cg, lo pueden editar en codeblocks en File->new->File escogen Empty File y le ponen nombredearchivo.cg y listo para editarlo.

El programa para cambiar el color a rojo es el siguiente:

struct Salida{

  float4 position : POSITION;

  float4 color    : COLOR;

};

Salida mainv(uniform float4x4 ModelViewProj,float2 position : POSITION)
{
  Salida OUT;
  OUT.position = mul(ModelViewProj, float4(position, 0, 1));
  OUT.color    = float4(1, 0, 0, 1);  //poniendo el color en rojo
  return OUT;
}

El resultado es el siguiente:

Sin shader                                         Shader aplicado     

Este es un sencillo ejemplo. Para comenzar creo que esta bien.
Ahora a crear y desarrollar! .....

Configurar CG en Codeblocks

Configuración de opengl en codeblocks con Qt para realizar las pruebas.

1. En Codeblocks agregar las librerias de opengl:
 
En settings->compiler and debugger en la pestaña Linker settings  agregar libopengl32.a y libglu32.a que     se encuentan en la carpeta lib de mingw y libQTOpenGL4.a que se encuentra en la carpeta lib de Qt.

2. Luego seguir los ejemplos de qt para opengl que se encuentran en assistant de qt y listo!

3. Es necesario incluir gl.h y glu.h en los archivos para poder utilizar code-completion de codeblocks.

Nota1: en el punto 2 adicionarlibQTOpenGL4.a para modo debug y release, No agregar la librería lógica para modo debug libQTOpenGLd4.a ya que genera problemas con qglwidget.



Configurando CG

1. bajar el cg toolkit de la pagina de nvidia(hay que registrarse).

2. En settings->compiler and debugger en la pestaña Linker settings la librerias de cg que se encuentran en la carpeta lib del cg toolkit estas son cg.lib que es para todos y cgGl.lib para opengl, para direct3d escoger la librería con la version del sistema.

3. En search directories agregar la ruta de include del cg, y en el archivo de opengl incluir cg.h y cgGl.h si se trabaja con opengl.

4. Los archivos cg se editan en codeblocks aunque no es posible utilizar code-completion ni nada por el estilo, codeblocks abre los archivos cg ya que estan relacionados con el entorno.

5. Para encontrar errores en los archivos cg es posible utilizar el compilador cgc.exe antes de ejecutar el programa, pero como la compilacion de los archivos cg viene en tiempo de ejecución yo prefiero utilizarlo de esta manera, en mi siguiente post pondre un ejemplo sencillo para poder iniciar.

Nota2: al adicionar las librerias e includes en settings->compiler and debugger estamos agragando estos elementos para todos los proyectos, si se quiere se puede adicionar esto a cada proyecto con click derecho sobre el proyecto y escogiendo Build options.

Instalar QT para Codeblocks

Primero que todo descargar las librerías de Qt para minGW ya que si se esta utilizando codeblocks es muy acertado utilizar las librerías de minGW para compilar. Las librerias se encuentran en: http://qt.nokia.com/downloads

Seguir los siguientes pasos:
1. Instalar las librerías preferiblemente en la unidad C: , D: etc.
2. En settings->compiler and debugger->Linker settings en link libraries adicionar:

     C:\Qt\4.7.3\lib\libQtGui4.a
     C:\Qt\4.7.3\lib\libQtCore4.a

3. En search directories adicionar
     C:\Qt\4.7.3\include
     C:\Qt\4.7.3\include\QtCore
     C:\Qt\4.7.3\include\QtGui

4. En settings->gloval variables new en el textbox poner el nombre, que puede ser: qt
    En base poner C:\Qt\4.7.3\
    En user-defined fields:
    Primer texbox  mkspecs
    Segundo texbox $(#qt)mkspecs
 
NOTA1: no olvidar agregar la carpeta C:\Qt\4.7.3\bin al path en las variables de entorno de windows ya que sin esto no podrán utilzar moc, qmake ni uic directamente.

Para utilizar el Qtdesigner es necesario lo siguiente:

1. crear el widget o window en el QTdesigner.
2. guardar el archivo en la carpeta de nuestro proyecto.
3. crear el header del archivo ui. Para crear el header en consola estando en el directorio del proyecto:
   uic nombrearchivo.ui -o nombrearchivo.h
4. incluir el archivo de cabecera donde sea necesario este sera el archivo generado con nombrearchivo.h
5. es necesario crear los makefiles y el archivo .pro para esto en consola estando en el directorio del proyecto. qmake -proyect y luego qmake.

NOTA2: Hay un error (undefined reference to `vtable for ') que se genera por utilizar la macro Q_OBJECT sin tener los archivos moc generados para eso:
En consola y en el directorio del proyecto:

1. Poner en consola moc nombrearchivo.h -o moc_nombrearchivo.cpp
2. Luego en el archivo nombrearchivo.cpp poner #include "include moc_nombrearchivo.cpp"

En este caso el archivo nombrearchivo utiliza la macro Q_OBJECT necesaria para utilizar signals y slots.

Humanoide en UDK

Ahora el humanoide creado en blender hace su aparición en Unreal development Kit, el modelo fue importado como un archivo .ASE y por lo tanto simplemente es un static mesh en UDK, ya que aun no tiene esqueleto.

El material fue creado en UDK simplemente con 3 nodos 2 de constantes para el specularColor y  diffuseColor, y uno último para el mapa de normales.

En la siguiente imagen se muestra al humanoide en un sencillo mapa en UDK.

Blender bump map humanoide

Ahora a el modelo de humanoide mostrado en un post anterior se le a construido un traje el cual se refino con sculpt, lo que se hizo fue utilizar el modelo con mayor numero de polígonos y obtener con este los normal maps, por ultimo se utilizaron estos mapas en el modelo de baja resolución , la primera imagen es el modelo de baja cantidad de polígonos vs el de alta cantidad.

Low poly            vs        high poly

Y en la siguiente imagen se ve el resultado de adicionar los normal maps al modelo de pocos poligonos.

Con Bump mapping

Se ve una mayor aproximación entre los modelos aunque aun se ven diferencias en los picos de la chaqueta. Para arreglar esto hice un primer intento cambiando la malla de la chaqueta en low poly con el modificador displace utilizando un mapa de desplazamiento y luego creando otro mapa de normales, en la siguiente imagen se ve el resultado.

Se ve aun mejor los picos en la chaqueta y esto es un buen camino para obtener un resultado mas aproximado al modelo de alta cantidad de polígonos.

Instalación Mingw y mingw64 en Codeblocks

Aquí pongo la instalación de Mingw en codeblocks y como configurarlo para 32 y 64bits


1. encontrar el paquete mingw que mas se adecue
   se pueden encontrar en:
   www.mingw.org es un paquete estandar muy actualizado. preferible para 32bits
   La forma mas facil para utilizarlo
   downloads luego Automated MinGW installer y bajar mingw-get-inst
   en:
   http://tdm-gcc.tdragon.net/ seleccionar download, la forma facil bajar bundle installer
   ya sea para 32 o 64 bits
   en:
   http://mingw-w64.sourceforge.net/ el mas complicado de bajar, para 64 bits preferiblemente
   primero ir en el menu home al link what do I download para entender que paquete bajar, y luego
   ir a win64 downloads o win32 downloads, alli se puede escoger entre personal builds y
   automated builds si escogen el segundo los ejecutable tendran un prefijo
   en ese caso para utilizar g++ es necesario poner x86_64-w64-mingw32-g++ [archivo]
   si se escoge el segundo no hay ese problema, en mi caso prefiero el segundo, ademas son
   paquetes con utilidades que utilizo mas como gendef.exe.

2. instalar es facil
   para 32 bits: en codeblocks ir a settings y en selected compiler escoger GNU GCC compiler y
   en la pestaña Toolchain executables buscar el directorio de mingw en mi caso, C:\MinGW\
   se configura por si solo o si no, escoger:
   C compiler= gcc.exe o mingw-gcc.exe depende del paquete. y asi con el resto

   para 64 bits prefiero hacer otra configuracion, en selected compiler seleccionar copy y en el
   dialogo poner el nombre en mi caso Mingw64 compiler escogerlo e ir a toolchain executables y
   poner:

   Compiler's installation directory: C:\mingw64

   C compiler: gcc.exe
   C++ compiler: g++.exe
   Linker for dynamic libs: g++.exe
   Linker for static libs: ar.exe
   Debugger: There isn't one for MinGW 64-bit yet, clear this and leave it blank
   Resource compiler: windres.exe
   Make program: make.exe

   La instalacion de 64bits la encontre en:
   http://forums.codeblocks.org/index.php?topic=13016.0

  Nota: los ejecutables pueden tener otros nombre escogerlos por ejemplo en mi caso
  make.exe tenia un prefijo mingw32-make.exe

3. y listo a programar.

Reptiloide en 3dsmax

Modelo con blueprint

El cuerpo de este modelo fue realizado con polígonos y la cabeza con splines en 3dsmax, seguramente este diseño va a ser uno de los enemigos en el juego, en cuanto a este modelo es mucho mejor realizado ya que este si fue realizado con blueprints. los blueprints fueron unos bocetos hechos por mi.

Humanoide en blender

Humanoide sin Blueprints

Este es un modelo hecho en blender, realmente es un modelo muy sencillo, hecho sin ninguna referencia y todo modelado con polígonos, posiblemente va a ser uno de los personajes del juego que estoy planeando hacer pero ya que es un modelo sencillo sera muy útil como prototipo.