miércoles, 15 de febrero de 2012

La mansión texturizada en Blender


En este post muestro a la mansión ya texturizada, todas las texturas fueron creadas desde cero a partir de patrones prediseñados o diseñados en inkscape.

Para hacer el texturizado use las siguientes herramientas:

MapZone: excelente programa para realizar texturas nuevas a partir de imágenes .png o de archivos svg, este programa contiene muchos patrones generados matemáticamente para poder crear nuestras texturas.

Gimp: lo utilice para convertir algunas imágenes en tileables y hacer muchos arreglos en las texturas y lógicamente crear varias texturas.

Inkscape: muy útil para hacer patrones que queramos tener en nuestras texturas los cuales no puedan ser generados por algoritmos matemáticos,  por ejemplo  muy útil para crear la parte no transparente de una ventana.

Blender: lógicamente con su herramienta bake nos ayuda a ajustar las texturas como las queramos a nuestros modelos 3D y además podemos crear texturas que en otra forma seria más difícil.

Nota1: MapZone es la base para el programa de pago Substance Designer.

Nota2: en Gimp es posible sacar el mapa de normales añadiendo un plugin para esta labor que es el mismo que se utiliza para Photoshop pero yo recomiendo MapZone por su flexibilidad.

En las siguientes imágenes se ve el proceso de texturizado.











Bueno enseguida algunas imágenes de la mansión texturizada en su mayoría.








Finalmente el vídeo con la canción If de Peter Rudenko



También se puede ver el vídeo en:  http://vimeo.com/36837879

martes, 6 de diciembre de 2011

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!.



jueves, 24 de noviembre de 2011

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.


martes, 15 de noviembre de 2011

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.

jueves, 10 de noviembre de 2011

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!

lunes, 7 de noviembre de 2011

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!



jueves, 27 de octubre de 2011

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:

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



miércoles, 12 de octubre de 2011

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!


lunes, 26 de septiembre de 2011

Instalar Bullet Physics para Codeblocks

1. Bajar la última versión de bullet en:
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!

viernes, 16 de septiembre de 2011

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.

jueves, 15 de septiembre de 2011

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.




jueves, 8 de septiembre de 2011

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!.

martes, 6 de septiembre de 2011

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.

miércoles, 31 de agosto de 2011

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.



jueves, 25 de agosto de 2011

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.


miércoles, 17 de agosto de 2011

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.