Este artículo completa el que publiqué la semana pasada y que puede acceder haciendo click aquí.

Librerías de ayuda a la generación del glue code

Por lo general lo más dificultoso, en la integración de un motor de scripts a un motor de juegos, pasa por la exportación del modelo de objetos para que el mismo sea visible desde el script. Este código, denominado “glue code”, generalmente está relacionado a la exportación de funciones y mapeo de tipos de datos.

De esta manera, si poseo un personaje y quiero que el mismo se traslade de un posición A a una posición B deberé poder dar estas instrucciones desde Python (o el lenguaje de script que corresponda) para que esto suceda, además desde el script deberé poder consultar o recibir información acerca de la interacción de un determinado objeto o personaje con el mundo (ej: colisiones).

Existen diversas soluciones para generar este código de manera “automática” o, mejor dicho, de una manera menos manual. Veamos algunas de ellas:

. Para Lua podemos utilizar la herramienta/librería ToLua (http://www.tecgraf.puc-rio.br/~celes/tolua/tolua-3.2.html).

. Para Python (y otros lenguajes de scripts) podemos utilizar la librería Swig (Simplified Wrapper and Interface Generator) (http://www.swig.org).

ToLua

ToLua es una herramienta que podremos descargar de modo libre desde http://www.tecgraf.puc-rio.br/~celes/tolua/

Haciendo uso de esta herramienta, la cantidad de código que deberemos escribir para integrar scripts Lua con nuestros programas será mucho menor.

La herramienta se encuentra compuesta por dos componentes:

. Un precompilador (una utilidad que lee un archivo de nuestro proyecto y genera código en lenguaje C++)
. Una librería que debe ser incorporada a nuestro proyecto.

Vayamos al ejemplo de acceso a una clase de nuestra librería (que es el caso más común en nuestros programas C++). Supongamos que tenemos la siguiente clase:

Archivo: ClaseFoo.h

| class ClaseFoo
| {
| public:
| ClaseFoo();
| ~ClaseFoo();
|
| int m_valor;
|
| void SetValor(int iVal);
| int GetValor();
| };


Entonces, deberemos crear otro archivo llamado, por ejemplo, ClaseFoo.pkg que será un archivo cabecera pero simplificado y donde no se incluirán los métodos o propiedades privadas o protegidas que deseamos esconder de Lua, veamos:

Archivo: ClaseFoo.pkg


| #include "ClaseFoo.h"
| class ClaseFoo
| {
| public:
| ClaseFoo();
| ~ClaseFoo();
| int m_valor;
|
| void SetValor(int iVal);
| int GetValor();
| };


Como se puede apreciar la sintaxis es casi la misma del archivo cabecera. Notemos que existe un include colocado con un $ delante, esto es para que la herramienta ToLua no lo interprete y simplemente lo transfiera al archivo C++ generado (esto será necesario, pues ClaseFoo hace referencia a la clase declarada en ClaseFoo.h).

Ahora, este archivo lo procesaremos con la herramienta:
tolua -o clasefoo.cxx clasefoo.pkg

La herramienta tomará como entrada al archivo clasefoo.pkg y creará la salida con el nombre de clasefoo.cxx (que es una terminación válida de un archivo C++).

Extracto del archivo generado:


|
| /*
| ** Lua binding: clasefoo
| ** Generated automatically by tolua 5.0a on 11/15/04 20:12:58.
| */
|
| #ifndef __cplusplus
| #include "stdlib.h"
| #endif
| #include "string.h"
|
| #include "tolua.h"
|
| /* Exported function */
| TOLUA_API int tolua_clasefoo_open (lua_State* tolua_S);
|
| #include "ClaseFoo.h"
|
| /* function to release collected object via destructor */
| #ifdef __cplusplus
|
| static int tolua_collect_ClaseFoo (lua_State* tolua_S)
| {
| ClaseFoo* self = (ClaseFoo*) tolua_tousertype(tolua_S,1,0);
| delete self;
| return 0;
| }
| #endif
|
| /* function to register type */
| static void tolua_reg_types (lua_State* tolua_S)
| {
| tolua_usertype(tolua_S,"ClaseFoo");
| }
|
| /* method: new of class ClaseFoo */
| static int tolua_clasefoo_ClaseFoo_new00(lua_State* tolua_S)
| {
| #ifndef TOLUA_RELEASE
| tolua_Error tolua_err;
| if (!tolua_isusertable(tolua_S,1,"ClaseFoo",0,&tolua_err) ||
| !tolua_isnoobj(tolua_S,2,&tolua_err))
| goto tolua_lerror;
| else
| #endif
| {
| ClaseFoo* tolua_ret = (ClaseFoo*) new ClaseFoo();
| tolua_pushusertype(tolua_S,(void*)tolua_ret,"ClaseFoo");
| }
| return 1;
|
| #ifndef TOLUA_RELEASE
| tolua_lerror:
| tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
| return 0;
| #endif
| }
| // ...


En total el archivo anterior posee 216 líneas y será compilando como otro archivo más de nuestro proyecto (por lo que hay que adjuntarlo al mismo ni bien este es generado).

Dentro del archivo anterior existe una función global que fue escrita y se llama: tolua_clasefoo_open. Esta función debe ser invocada antes del script que haga referencia a la clase debido a que es allí donde se registra el tipo.

Hecho esto, podremos hacer uso de la clase ClaseFoo dentro del script Lua, como en el siguiente ejemplo:


| foo = ClaseFoo:new()
| foo.m_valor = 99
| print(foo:GetValor())


Para que sea posible crear objetos del tipo ClaseFoo dentro de Lua es necesario que la clase ClaseFoo tenga declarado de manera explícita al menos un tipo de constructor.

Entonces, por cada clase que deseemos exponer a lua deberemos crear un archivo pkg que luego deberemos precompilarlo con tolua. Realizar esta operación manualmente bastante trabajoso y usualmente es recomendable configurar nuestro entorno de programación para que lo haga por nosotros. Si estamos trabajando con Visual Studio, para ello deberemos seguir los siguientes pasos:

1. Incluir el archivo pkg en nuestro proyecto.

2. Mover el archivo en el panel “Solution Explorer” desde “Solutions Items” a “Source Files”:

3. Acceder a las propiedades del archivo clasefoo.pkg y en la sección “Custom Build Setup” agregar en:

CommandLine: tolua -o $(InputName).cxx $(InputName).pkg

$(InputName) es una variable que representa el nombre del archivo.

Description: Precompilando con ToLua

Aquí podremos especificar la descripción que deseemos (este mensaje aparecerá en la ventana “Output” cuando el entorno de desarrollo esté trabajando en la construcción del proyecto.

Outputs: $(ProjectDir)/$(InputName).cxx

Indicamos cual será el nombre y ubicación del archivo de salida.

4. Precompilado por primera vez el archivo pkg, agregamos su salida al proyecto (el archivo del tipo cxx) para que sea compilado convenientemente.

Pages: 1 2

Comentarios (1)