Lenguaje de scripting Lua

Cuando empezamos a programar nos situamos en un proceso intermedio que fragmenta  el código para  comprenderlo, y posteriormente relacionar esas unidades en estructuras cada vez más complejas, hasta llegar a escribir pequeños programas propios. Estos métodos de análisis articulan el programa en pequeñas estructuras significativas que ayuden a comprender y aprender a diseñar la estructura de código.

[…] los expertos no sólo tienen más información, sino que la tienen mejor organizada. En lugar de percibir y recordar piezas individuales de información, procesan la información como grupos significativos, por lo que su percepción es más eficiente y su capacidad de recuerdo tiene un rendimiento mucho más alto. (McKeithen 1981, 307)

Programar es diseñar algoritmos, lo que implica pensar en situaciones abstractas que se planifican de forma lógica para generar procesos, o comportamientos, mediante una serie de instrucciones consecutivas. Las instrucciones tienen que ser entendidas por el sistema, por lo que no pueden ser ambiguas. De ahí que se aconseje hacer previamente un esquema mediante diagramas de flujo, o de otro tipo, siguiendo un lenguaje «pseudohumano», enlazando las instrucciones en secuencias que sigan un orden.

En el campo del arte estamos más acostumbrados a pensar en imágenes o estructuras para expresar una idea que en algoritmos y lógica, por eso los software de código creativo están orientados a visualizar las formas o imágenes en pantalla rápidamente, utilizando un lenguaje de programación muy simplificado.

Mosaic simplifica esta situación al incorporar en la programación visual un objeto específico para escribir código, el objeto lua script.

El entorno de programación de scripting que hay bajo este objeto incorpora el paquete de librerías oficiales de openFrameworks pero utilizando para su uso el lenguaje Lua, que no necesita compilar. Tendremos por tanto funciones de Lua, de openFrameworks (se diferencian por empezar con of.xxxxx) y algunas funciones propias de Mosaic.

Comprendida la estructura técnica que sustenta el entorno de programación, el proceso de trabajo en un proyecto de arte interactivo sigue inicialmente pasos semejantes a cualquier proyecto artístico:

–    Analizar qué es lo que se quiere expresar y cuáles son los recursos que mejor lo pueden reflejar.

–    Planificar las distintas partes en que se pueda dividir ese proceso con una secuencia de etapas más simples. Hacer esa planificación en un bosquejo sobre papel ayuda a ver las relaciones y orden de esos pasos. El dibujo es el mejor y más rápido aliado del pensamiento y ese esquema o bosquejo permite ver la finalidad de cada una de esas etapas simples, qué datos necesita de entrada y cuáles produce como salida.

Un buen bosquejo en papel del software debe incluir una serie de imágenes que muestren cómo funciona la estructura narrativa de la pieza, de forma semejante al guión gráfico de una animación. Además de las imágenes que genera en pantalla, los bocetos a menudo contienen diagramas de flujo del programa, los datos y anotaciones para mostrar cómo las formas se mueven e interactúan. Los programas también pueden planificarse utilizando combinaciones de imágenes, esquemas formales y descripciones de texto (Reas y Fry 2007, 145).

–    Escribir cada una de esas fases en archivos separados y comprobar que funcionan, corrigiendo errores si los hubiera.

–  Combinar los distintos archivos comprobando que no hay errores de lógica entre ellos, ni cálculos innecesarios y que los datos de salida son los que se buscaban.

–   Documentar el código con comentarios, hacer una breve explicación al inicio del planteamiento y en los argumentos de entrada y salida.

Para comprender el sentido de estos procesos es muy importante visualizar referencias que muestren dónde y cómo se aplican o se han aplicado procedimientos semejantes en resultados concretos. Lo que en el campo del arte entendemos como referentes artísticos, o contextualización referencial.

Aun conscientes de esta necesidad referencial, para iniciar el aprendizaje hay algunas estructuras, funciones y expresiones básicas que deben conocerse en su conjunto antes de trabajar con ellas, por eso se recomienda alternar la lectura de este capítulo con los siguientes para comprender su aplicación gráfica. Tras pasar estos peldaños, entraremos ya en las cuestiones de programación visual e interactividad con el uso de los objetos y la interface de flujo de señales entre ellos (cables), con ellos y la base adquirida de programación se pueden plantear y resolver proyectos creativos de arte digital e interactivo complejos.   

Elementos básicos de programación: datos, variables y funciones

Un dato por sí mismo no genera información, es el contexto y el procesamiento de los datos lo que  da sentido al proceso y resultado.

Como anticipo nos detendremos en la Fórmula giratoria del Computer art que proponía Jim Campbell, con elementos de entrada (input), procesamiento, y salida (output). Es común que las piezas de arte digital recojan datos del entorno, ya sean del contexto físico exterior, del propio planteamiento del autor, o de la interacción del espectador. Estos datos entran al ordenador (input) mediante un interprete (sensores, teclado, ratón…) son procesados de forma invisible (algoritmo, memoria) y producen una respuesta sensitiva (output).

DATOS (INPUT) -> PROCESAMIENTO ->  (OUTPUT) INFORMACIÓN

Siguiendo esta fórmula, los datos de entrada al sistema pueden estar relacionados con el viento, lluvia, temperatura, tiempo, terremotos, stocks de mercado, niveles de luz…, pero más allá del origen de los datos, es necesario saber cuál es su naturaleza. Así, los datos del viento pueden ser numéricos (velocidad km/h), letras (direcciones N, S, E, O), palabras (nombres locales de los vientos), imágenes (fotografías, gráficos, etc) o vectores (dirección o intensidad)

La base del software es el procesamiento de datos y necesita conocer su naturaleza porque la cantidad de memoria que debe reservar es muy diferente para un número o para una cadena de caracteres y mucha más para una imagen o para una gran cantidad de números organizados en matrices. La memoria retiene la información de los datos para que puedan ser utilizados repetidas veces. Este espacio reservado de la memoria está vinculado con las Variables.

El siguiente gráfico despliega la fórmula Computer art de Jim Campbell, fijando su movimiento.

Variables

Una variable es como un contenedor para almacenar datos que después pueden ser reutilizados muchas veces en el programa y cuyo valor puede cambiar. El sistema necesita reservar determinada cantidad de bits de memoria para que esa variable esté siempre disponible. Para comprender cómo se estructuran las variables en programación básica —cómo se identifican y diferencian los datos—, vamos a comparar su uso en Lua y Processing, por ser uno de los software más utilizados y documentados en este tipo de aplicación creativa. En Processing, cada variable tiene tres partes:

• identificación del tipo de datos que guarda (int, float, boolean,…)
• nombre (el que decida el programador)
• valor (se asigna un valor inicial)

Processing necesita hacer constar esa identificación, distinguiendo entre:

int      -- Número entero        

float    -- Número con coma flotante

boolean  -- Un dato que sólo puede ser verdadero o falso.

PImage   -- Imagen

char     -- Carácter. El valor se define con apostrofes: ‘a’ 

string   -- Cadena de caracteres. Se define con comillas "antes"

PFont    -- Fuentes tipográficas

En Lua a las variables no se les asigna el tipo, porque es un lenguaje «dinámicamente tipado», si bien el programador debe ser consciente del tipo de datos que alberga esa variable. Siempre hay que declarar la variable antes de utilizarla, en Lua además hay que asignarle un valor que en el proceso del programa puede cambiar; en Processing es opcional, puede declararse y posteriormente darle un valor, como muestra la segunda variable en el siguiente ejemplo:

Processing                                                                              Lua-Mosaic

int miTiempo = 50;                              miTiempo = 50

float y;                                        y = 0.0

boolean b = true;                               b = true

PImage myImage;                                 myImage = of.Image()

Cada programador decide cómo nombrar las variables, pero algunos hábitos han generado una cuasi-norma:

• Se recomienda poner a las variables un nombre relacionado con su contenido, para que sea más fácil leer la programación y se reduzca la necesidad de comentarios.
• Los nombres de las variables suelen comenzar con una letra minúscula, y si hay varias palabras en el nombre, la primera letra de cada palabra adicional está en mayúscula (como miTiempo)

Hay también algunas normas para nombrar variables:

• El nombre de una variable tiene que ser una sola palabra y no puede empezar con números.
• No puede coincidir con los términos propios del lenguaje de programación.

Palabras reservadas en Lua son:

and    break     do     else    elseif    end     false     
for    function  if     in      local     nil     not
or     repeat    return then    true      until   while

Para evitar confusiones, los nombres de las variables tampoco deberían coincidir con otros nombres que reconoce el sistema como angle o int. Si al escribir una variable se colorea, siempre puede readaptarse para mantener su sentido, como por ejemplo: _angle.

Para modificar el tipo de dato de una variable se pueden utilizar las siguientes funciones de Lua o de openFrameworks:

tostring() el argumento que acoge entre los paréntesis puede ser de cualquier tipo de datos y lo convierte en un string (cadena de caracteres) con un formato razonable.

Para un mayor control en la conversión de datos numéricos a string es aconsejable usar string.format()dado que incorpora códigos para especificar el tipo de dato, los principales códigos son:

string.format("%s" , 100)      -- %s devuelve un string 	 							
100 
  																								
string.format("%c", 76)        -- %c devuelve un carácter, char						
L
																										
string.format("%f", math.pi)   -- %f devuelve un float como string					
3.141593 
 																							
string.format("%i,%i",-100,100) -- %i  número entero con su signo como string	
-100, 100

string.byte('L') 	        --devuelve el código numérico de los caracteres			     	
76																							

Otras funciones útiles de openFrameworks para convertir otros tipos de dato son:

of.toFloat("3.14") -- Convierte un string (float-string) en un valor float 
3.14 

of.toInt("100")    -- Convierte un string (int-string) en un valor int 
100 

of.toBool("true")  --Convierte un string (bool-string) en un booleano real 
true

Otra cuestión importante en relación a las variables es el alcance o ámbito de la variable, es decir, dónde puede ser utilizada en relación a dónde se ha creado o declarado, porque ello determina su ámbito de aplicación —dónde se puede acceder a ellas dentro del programa. Las variables declaradas dentro de un bloque se denominan locales y sólo son válidas dentro de ese mismo bloque o dentro de otros bloques encerrados en él. Las variables declaradas al iniciar el script —antes del setup()— se denominan globales y se pueden utilizar en cualquier parte. Si las variables están declaradas dentro del setup() sólo se pueden utilizar en el bloque setup(), igualmente, si se han declarado en el draw() sólo son válidas en el bloque draw(). El siguiente ejemplo muestra el alcance de las variables dentro de una estructura de código que se describe en el siguiente apartado.

d = 50           -- d y val son variables globales,			
val = 0          -- se pueden usar en cualquier lugar 
    
function setup()
end

function update()      
  val = d * 0.7   -- sus valores se actualizan en el bloque update()		
  d = d + 1	
end	
                                                
function draw() 							   													
  of.setColor(val)									 											
  y = 150                      -- y es variable local, se puede usar solo en draw()		
  of.drawLine(0, y, d, y)      -- d e y son llamadas desde draw()
  y = y - val                  -- el valor de y se relaciona con el de val			
  of.drawLine(0, y, d, y)	

  if d > 50 then	
    x = 10                     -- x es variable local solo se puede usar en bloque if	
    of.drawLine(x, 40, x+d, 40)								 							
  end																								
  of.drawLine(0, 50, d, 50)								   									
  of.drawLine(x, 60, d, 60)    -- ERROR x no se puede usar fuera del bloque if
end

Hay otro tipo de variables que se denominan variables del sistema o constantes, tienen un nombre asignado por el propio software que le otorga ya su valor. En Lua-Mosaic se reconocen:

Ancho de la ventana de salida                OUTPUT_WIDTH

Alto de la ventana de salida                       OUTPUT_HEIGHT

Array datos de entrada desde otros objetos  _mosaic_data_inlet

Array datos de salida desde objeto Lua Script  _mosaic_data_outlet

De OpenFrameworks: Las asociadas a las funciones y clases de openFrameworks incluidas en Mosaic.

Funciones

Fue Leibniz quien en el siglo XVII acuñó los términos «función», «variable», «constante» y «parámetro». El campo de la programación ha readaptado estos términos a su contexto, siendo aquí las funciones pequeñas partes del código que realizan tareas particulares (que tiene una función determinada), también se define como un subalgoritmo que se encarga de realizar instrucciones concretas dentro de una secuencia mayor de instrucciones.

El lenguaje scripting Lua en Mosaic, como todo software, requiere una terminología específica y, para facilitar el aprendizaje, el nombre de las funciones se ha mantenido lo más próximo posible al utilizado en otros lenguajes de programación creativa como Processing y openFrameworks. En las funciones debemos diferenciar entre los bloques de funciones, las funciones internas del software y funciones escritas por cada programador (custom functions), pero para no complicar las definiciones vamos a ir señalando sus diferencias con ejemplos que muestren la estructura de programación. Empecemos viendo cuál es la estructura básica de un programa.

El sistema lee el código desde arriba hacia abajo y lo primero que aparece en la imagen son los comentarios. En Lua, los comentarios de línea se señalan con --. Son dos signos consecutivos, pueden ponerse más de dos, pero si las dos primeras barras están más separadas el sistema no lo reconoce como comentario y da error, se puede detectar el fallo si el texto no adopta el color gris que se les asigna por defecto.

Cuando el comentario ocupa  varias líneas (bloque de comentario), se señalan al principio con  --[[ y   al final del comentario  con ]].

Los comentarios son textos que el sistema ignora, no los procesa, pero son importantes para el programador. El código de programación puede ser muy breve y fácil de leer o tremendamente extenso, por lo que es fundamental acostumbrarse a comentarlo bien y también a ordenar y tabular las líneas de código según niveles para facilitar su lectura y revisión. Lua no da error si las tabulaciones no están bien ordenadas como en phyton, pero es importante ordenarlo bien para verificar que todos los bloques están cerrados con un «end».

Tras los comentarios, están las variables globales y después los bloques de funciones que estructuran y contienen el código, estas líneas de código pueden ser funciones internas, funciones custom, o expresiones aritméticas , según las acciones que deban realizar. Por defecto, en el code editor de Mosaic, el nombre de las funciones aparece de color azul  y los términos que marcan los bloques de la estructura de programación en rosa.

En Lua el final de cada bloque de función se señala con el término end, no usa signos de corchetes {} que marquen principio y final.

Los bloques básicos son:

function setup()                -- solo se ejecuta una vez									
end
                                              
function update()               -- donde se actualizan las variables, se lee en loop	
end
                                              
function draw()                 -- donde va el código a dibujar, se lee en loop.		
end
                
function exit()                 -- Respuesta a inputs 
end

function mouseDragged(x,y)      -- cuando la acción se da al arrastrar el ratón 	
end
                                              
function mouseMoved(x,y)        -- el código actúa cuando se mueve el ratón                               
  mouseX = x                    -- actualiza la posición (x, y) del ratón
  mouseY = y		
end

function mouseReleased(x,y)     -- actúa cuando se suelta el botón 
end

function keyPressed(key)        -- el código actúa cuando se presiona una tecla	
end

function keyReleased(key)       -- el código actúa cuando se suelta una tecla	
end

Después de los bloques, el siguiente elemento importante son las funciones internas. En Lua-Mosaic, además de las funciones propias del lenguaje Lua, están las que provienen de openFrameworks, casi mantienen su nombre original, por ejemplo, si en openFrameworks se escribe ofSetColor() en Lua-Mosaic es of.setColor().

Las funciones siempre terminan con dos paréntesis que pueden albergar, o no, parámetros. Los parámetros se sitúan entre los paréntesis, separados por comas, y afectan el modo en que actúa la función. Algunas funciones no tienen parámetros, como of.noFill(), y otras pueden albergar más o menos parámetros según la situación, como of.setColor() que puede tener 1 parámetro o 4:

of.setColor(255)               -- color en escala grises [de 0 (negro) a 255 (blanco)]

of.setColor(255, 255, 255, 10) -- (R, G, B, alpha)

Además de las funciones internas propias del software, cada programador puede hacer sus propias funciones custom, que tendrán el nombre que quiera darle (se aconseja que el nombre indique lo que va a hacer) y están desarrolladas como un bloque, para después ser llamadas en alguno o varios de los bloques del sistema.

En el siguiente fragmento de código (Extraído del ejemplo: examples / livecoding / lua / Basics / Array / RandomTable / RandomTable.lua) hay una función custom para resetear los valores de color de una tabla.

Esta función custom es llamada en el bloque setup() que sólo se lee una vez.

Y también es llamada en el bloque mouseReleased(), por lo que cada vez que se suelte el botón del ratón se volverán a resetear los valores de color de la tabla.