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!

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.

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.