Lobo tuerto

¿Por qué NetBeans? porque me gusta.

Lo he estado usando para el último proyecto Rails en el que he trabajado y se me hace un IDE muy bueno. Si quieren leer sobre sus capacidades específicas para C/C++ pueden hacerlo aquí: C/C++ features.

Se que muchos han escuchado que necesita grandes cantidades de recursos, que es muy lento y otras tantas cosas más, yo solo les digo que antes de juzgar lo prueben.

Aprovechen, acaba de salir la versión 6.1.

Objetivo

El objetivo de este tutorial es configurar NetBeans para poder compilar desde ahí nuestras aplicaciones basadas en Irrlicht.
Y crearemos nuestro primer programa usando este poderoso motor gráfico, así es, ¡un Hola Mundo con Irrlicht!

Tutoriales pasados

Tutorial #1 de Irrlicht: Cómo compilar e instalar Irrlicht en Ubuntu 8.04

Instalar software necesario

Checa esta guía: Instalar Netbeans 6.1 en Ubuntu 8.04 Hardy Heron

Crear un nuevo proyecto C++

Este tutorial asume que ya tenemos compilado e instalado Irrlicht en nuestro sistema.
También que ya descargamos e instalamos NetBeans 6.1.

Vamos al menú File → New Project…

En Categories seleccionamos C/C++ y en Projects seleccionamos C/C++ Application.

En la siguiente pantalla le damos el nombre que queramos a nuestra aplicación, en mi caso decidí llamarla tutorial2.

Configurar las bibliotecas a enlazar

Ahora damos clic con el botón derecho sobre el nombre del proyecto y elegimos Properties.

En la ventana de propiedades del proyecto seleccionamos Build → Linker → Libraries → …

Aparecerá otra ventana donde podremos configurar las bibliotecas con las que vamos a enlazar nuestro proyecto.

Damos clic al botón que dice Add Library… y navegamos a nuestro directorio /usr/local/lib y damos doble clic sobre el archivo libIrrlicht.a

Repetimos el procedimiento para el archivo: libXxf86vm.a localizado en el directorio: /usr/lib

Y una vez más para /usr/lib/libGL.so.

Da clic en OK para guardar tus cambios y cerrar la ventana.

Estamos de regreso en las propiedades del proyecto, el campo de Libraries debe verse como en la imagen de al lado.

Escribir nuestro primer programa Irrlicht

En el panel de nuestro proyecto damos clic con el botón derecho sobre la carpeta llamada Source Files y seleccionamos New → Empty C++ File… y lo nombramos main.cpp (puedes ponerle el nombre que gustes).

Y ahora escribe el siguiente código en él.

#include <irrlicht.h>

/*
 * En el motor gráfico Irrlicht, todo puede ser encontrado
 * en el espacio de nombres (namespace) 'irr'.
 *
 * Si deseas usar una clase de este motor gráfico, debes
 * escribir 'irr::' antes del nombre. Por ejemplo para usar
 * el IrrlichtDevice debes escribir: 'irr::IrrlichtDevice'.
 *
 * Para deshacernos del 'irr::' le indicaremos al compilador
 * que vamos a usar ese espacio de nombres de ahora en
 * adelante.
 */
using namespace irr;

/*
 * Hay 5 sub espacios de nombres en el motor gráfico
 * Irrlicht.
 *
 * Puedes leer una descripción detallada acerca de ellos en:
 * http://irrlicht.sourceforge.net/docu/namespaces.html
 *
 * Así como con el espacio de nombres 'irr', le indicaremos
 * al compilador que usaremos los siguientes espacios de
 * nombres.
 */
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

int main() {

    /*
     * La función más importante en este motor gráfico es
     * 'createDevice', sirve para crear el 'Irrlicht Device'
     * el cual es el objeto raíz que sirve para hacer todo
     * en Irrlicht.
     *
     * createDevice() tiene 7 parámetros:
     *
     * deviceType: El tipo de dispositivo. Este puede ser un
     *  dispositivo nulo, un dispositivo de software, un
     *  dispositivo de software #2, D3D8, D3D9 u OpenGL.
     *  En este ejemplo usaremos el EDT_SOFTWARE, pero si
     *  gustas puedes probar con: EDT_BURNINGSVIDEO,
     *  EDT_NULL, EDT_DIRECT3D8, EDT_DIRECT3D9 o
     *  EDT_OPENGL.
     *
     * windowSize: Tamaño de la ventana o modo a pantalla
     *  completa a ser creado. En este ejemplo usamos
     *  640x480.
     *
     * bits: Cantidad de bits por pixel cuando estamos en
     *  modo a pantalla completa. Puede tomar el valor de
     *  16 o 32. Este parámetro es ignorado cuando se está
     *  en modo ventana.
     *
     * fullscreen: Especifica si queremos que el dispositivo
     *  se ejecute en pantalla completa o no.
     *
     * stencilbuffer: Especifica si queremos usar el stencil
     *  buffer para dibujar las sombras.
     *
     * vsync: Especifica si queremos tener activada la
     *  sincronización vertical (vsync), esto sólo es útil
     *  en el modo a pantalla completa.
     *
     * eventReceiver: Un objeto que recibe eventos. No
     *  vamos a usar este parámetro ahorita, así que lo
     *  dejamos en 0.
     */
    IrrlichtDevice *device = createDevice(EDT_SOFTWARE,
            dimension2d<s32 > (640, 480),
            16, false, false, false, 0);

    /*
     * Ahora le pondremos un buen título a nuestra ventana.
     * Podrás notar que hay una 'L' delante de la cadena.
     * Esto es porque Irrlicht emplea cadenas del tipo
     * 'wide character' para manejar texto.
     */
    device->setWindowCaption(L"Lobo tuerto - ¡Hola Mundo!");

    /*
     * Guardaremos un apuntador al manejador de video, otro
     * al administrador de escena y uno más al ambiente de
     * la interfaz gráfica de usuario (GUI), para no tener
     * que estar escribiendo siempre:
     *
     * device->getVideoDriver(),
     * device->getSceneManager() y
     * device->getGUIEnvironment().
     */
    IVideoDriver* driver = device->getVideoDriver();
    ISceneManager* smgr = device->getSceneManager();
    IGUIEnvironment* guienv = device->getGUIEnvironment();

    /*
     * Usando el ambiente GUI, agregaremos a la ventana una
     * etiqueta que diga 'Mi primer programa con Irrlicht'.
     */
    guienv->addStaticText(L"Mi primer programa con Irrlicht",
            rect<s32 > (10, 10, 260, 22), true);

    /*
     * Hagamos algo interesante, carguemos un modelo de
     * Quake 2 y mostrémoslo en pantalla.
     *
     * Primero debemos cargar el modelo usando el método
     * getMesh() en el administrador de escena
     * (SceneManager).
     *
     * Después debemos agregar un nodo de escena (SceneNode)
     * usando el método addAnimatedMeshSceneNode() para
     * poder mostrarlo en pantalla.
     *
     * También es posible cargar un modelo de Maya (.obj),
     * un mapa completo de Quake 3 (.bsp) o un archivo
     * de Milkshape (.ms3d) en lugar del modelo sydney.md2.
     * Por cierto el modelo llamado sydney fue hecho por
     * Brian Collins.
     */
    IAnimatedMesh* mesh = smgr->getMesh("sydney.md2");
    IAnimatedMeshSceneNode* node =
            smgr->addAnimatedMeshSceneNode(mesh);

    /*
     * Para hacer que el modelo se vea un poco mejor,
     * cambiaremos las propiedades de su material un poco.
     *
     * Primero deshabilitaremos la iluminación porque no
     * contamos con una luz dinámica por el momento y el
     * modelo se vería totalmente oscuro.
     *
     * Después definiremos el ciclo de cuadros de animación,
     * para que se reproduzca entre los cuadros 0 y 310
     * una y otra vez.
     *
     * Por último le pondremos una textura al modelo. Sin
     * ella el modelo sería dibujado en pantalla usando
     * puro color.
     */
    if (node) {
        node->setMaterialFlag(EMF_LIGHTING, false);
        node->setFrameLoop(0,310);
        node->setMaterialTexture(0,
                driver->getTexture("sydney.bmp"));
    }

    /*
     * Para poder ver el modelo, colocaremos en el espacio
     * 3D una cámara en la posición (0, 30, -40). La cámara
     * verá desde ahí hacia (0, 5, 0).
     */
    smgr->addCameraSceneNode(0,
            vector3df(0, 30, -40), vector3df(0, 5, 0));

    /*
     * Bueno, ya con la escena lista, podemos dibujar todo.
     *
     * Ejecutaremos el dispositivo en un ciclo while() hasta
     * que éste ya no quiera correr más. Esto sería después
     * de que el usuario cierre la ventana o presione
     * ALT+F4.
     */
    while (device->run()) {

        /*
         * Todo se dibuja entre una llamada a beginScene()
         * y endScene().
         *
         * La llamada a beginScene() limpia la pantalla con
         * un color y también el buffer de profundidad si
         * así lo deseamos.
         *
         * Ya con un espacio en limpio, dejamos que el
         * administrador de escena y el ambiente GUI
         * dibujen su contenido.
         *
         * Finalmente con la llamada a endScene() todo es
         * presentado en pantalla.
         */
        driver->beginScene(true, true,
                SColor(255, 217, 194, 140));

        smgr->drawAll();
        guienv->drawAll();

        driver->endScene();
    }

    /*
     * Después de terminar, debemos eliminar el Irrlicht
     * Device creado anteriormente con createDevice().
     *
     * En Irrlicht tendrás que hacerte cargo de eliminar
     * todos los objetos que hayas creado con un método o
     * función que su nombre comience con 'create'.
     *
     * El objeto se elimina simplemente al llamar a su
     * método drop().
     */
    device->drop();

    return 0;
}

 

Ejecutar el programa

Para ejecutar nuestro programa presionamos la tecla F6 o damos clic al tercer botón de los mostrados aquí (el verde).

Finalmente debemos ver algo similar a esto:

Lo que sigue

En la siguiente entrega de esta serie veremos cómo agregar a nuestra aplicación diferentes tipos de nodos y cómo modificar sus propiedades (posición, escala y rotación).

¡Hasta la próxima!

Referencias

Tutorial 1: HelloWorld
Irrlicht basics tutorial [Note: HUGE POST]