Explorando la Programación Creativa con Rust y ggez. Efecto Fuego.

Hoy vengo con algo un poco diferente, y es que desde que Rust se ha convertido en uno de los lenguajes moda y uno de mis favoritos para trabajar con Blockchain, me he preguntado, si no sería una buena idea usarlo para hacer algo de programación creativa, del estilo de la Demoscene que se hacía en los tiempos del Spectrum o de los ordenador de 16 bits. Por ejemplo, una de las demos más famosas, fue la de «Panic» del grupo FutureCrew, que sacaba un enorme partido a las máquinas de aquel entonces. Creo que podemos decir, sin lugar a equivocarnos, que la programación creativa es una disciplina emocionante que combina la programación con la expresión artística. En este artículo, te mostraré cómo puedes usar Rust, un lenguaje conocido por su rendimiento y seguridad, junto con la biblioteca ggez para crear proyectos de programación creativa.

La programación creativa es una forma de programación en la que el objetivo principal es crear algo expresivo en lugar de funcional. Es una intersección entre el arte digital y el código, donde el resultado suele ser una experiencia visual, auditiva o interactiva artística. La programación creativa se utiliza ampliamente en diversas áreas, incluyendo el arte digital, el diseño, la educación y el entretenimiento.

Aspectos Clave de la Programación Creativa

• Expresión: El enfoque principal está en la expresión artística y la creatividad, en lugar de resolver problemas prácticos.
• Exploración: Implica explorar los límites del código y experimentar con diferentes técnicas para lograr resultados únicos.
• Interactividad: Muchos proyectos de programación creativa son interactivos, permitiendo a los usuarios interactuar con la obra de arte de manera dinámica.
• Innovación: La programación creativa a menudo empuja los límites de la tecnología, llevando a usos innovadores y poco convencionales del código.

¿Por Qué Usar Rust y ggez?

Rust es un lenguaje de programación de sistemas conocido por su rendimiento, seguridad y concurrencia. Es una excelente opción para la programación creativa debido a su velocidad y fiabilidad, que son cruciales para renderizar gráficos complejos y manejar interacciones en tiempo real. La biblioteca ggez es un framework ligero para el desarrollo de juegos en Rust que proporciona las herramientas necesarias para gráficos, audio, manejo de entrada y más, lo que lo hace ideal para proyectos de programación creativa.

Primer Ejemplo: Simulación de Fuego

Uno de los proyectos que abordaremos en esta serie es una simulación de fuego, para mi es un clásico, dado que siempre lo uso como un mi particular «Hola Mundo», de hecho podéis ver un artículo muy antiguo mío (clic aquí), programandolo para el sistema operativo Tizen de Samsung. Este proyecto demostrará cómo crear un efecto de fuego dinámico y realista utilizando sistemas de partículas y gradientes de color.

A continuación, se explica brevemente cómo funciona, como veréis es un ejemplo muy bueno para practicar el uso de arrays de un modo un poco más divertido y original que el clásico ejemplo de sacar frutas o personas ;-):

Lógica de la Simulación de Fuego

1. Paleta de Fuego: Se utiliza una paleta de colores predefinida para representar diferentes intensidades de fuego, desde colores oscuros (baja intensidad) hasta colores brillantes (alta intensidad).
2. Array de Fuego: Un array 1D de valores u8 almacena las intensidades del fuego para cada píxel en una cuadrícula 2D.
3. Inicialización: El array de fuego se inicializa con ceros, y la fila inferior del array se establece con la intensidad máxima para crear la fuente del fuego.
4. Propagación: La intensidad del fuego de cada píxel se actualiza en función del píxel directamente debajo de él. Se resta un valor de decaimiento aleatorio para simular el enfriamiento del fuego a medida que asciende.
5. Renderizado: Cada píxel se dibuja como un rectángulo en la pantalla, con su color determinado por su valor de intensidad de la paleta de fuego.

Técnicas Utilizadas

1. Basada en Cuadrícula: El efecto de fuego se simula en una cuadrícula 2D donde el estado de cada píxel está influenciado por sus vecinos.

1. 1. 1. Cuadrícula 2D: Imagina una cuadrícula de píxeles donde cada píxel puede tener un valor de intensidad de fuego que va desde 0 (sin fuego) hasta 36 (fuego máximo).
      2. Inicialización: La fila inferior de la cuadrícula se inicializa con la máxima intensidad de fuego (36). Esto representa la fuente del fuego.
      3. Propagación: Para cada píxel en la cuadrícula, se calcula su nueva intensidad de fuego basada en el píxel directamente debajo de él. La intensidad del píxel superior se reduce por un valor de decaimiento aleatorio para simular el enfriamiento natural del fuego a medida que asciende.

Ejemplo Gráfico

Supongamos que tenemos una cuadrícula de 5×5 píxeles para simplificar el ejemplo. Aquí está la cuadrícula inicial con la fila inferior establecida en 36:

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[36, 36, 36, 36, 36]

Durante la propagación, cada píxel actualizará su intensidad basada en el píxel directamente debajo de él, restando un valor de decaimiento aleatorio (por ejemplo, entre 0 y 2).

Paso 1: Propagación Inicial

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[35, 35, 34, 34, 35]  <-- (36 - random decay)
[36, 36, 36, 36, 36]

Paso 2: Propagación Siguiente

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[34, 34, 32, 32, 34]  <-- (35 - random decay)
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Paso 3: Propagación Continua

[ 0,  0,  0,  0,  0]
[32, 32, 30, 30, 32]  <-- (34 - random decay)
[34, 34, 32, 32, 34]
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Visualización Gráfica

Aquí tienes una representación gráfica de cómo se propaga la intensidad del fuego en una cuadrícula 2D. La primera imagen muestra la cuadrícula inicial, y las siguientes muestran cómo se propaga el fuego hacia arriba.

Cuadrícula Inicial

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[36, 36, 36, 36, 36]

Propagación Paso 1

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Propagación Paso 2

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[34, 34, 32, 32, 34]
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Propagación Paso 3

[ 0,  0,  0,  0,  0]
[32, 32, 30, 30, 32]
[34, 34, 32, 32, 34]
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Espero que esta explicación y el ejemplo gráfico te ayuden a entender mejor el concepto de propagación basada en cuadrícula en la simulación de fuego.

2. Decaimiento Aleatorio: Se utiliza un valor de decaimiento aleatorio para simular el enfriamiento natural del fuego a medida que asciende, agregando variabilidad y realismo al efecto.

1. Valor de Decaimiento: Para cada píxel, se genera un valor de decaimiento aleatorio, generalmente entre 0 y 2. Este valor representa cuánto se reducirá la intensidad del fuego en ese píxel.
2. Actualización de la Intensidad: La intensidad del fuego del píxel superior se actualiza restando el valor de decaimiento aleatorio de la intensidad del píxel directamente debajo de él.
3. Variabilidad y Realismo: Al utilizar un valor de decaimiento aleatorio, se introduce variabilidad en la propagación del fuego, haciendo que el efecto sea más realista y dinámico. En la naturaleza, el fuego no se propaga de manera uniforme, y esta técnica ayuda a simular ese comportamiento.

Ejemplo de Decaimiento Aleatorio

Supongamos que tenemos una cuadrícula de 5×5 píxeles con la siguiente intensidad inicial en la fila inferior:

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[36, 36, 36, 36, 36]

Durante la propagación, cada píxel actualizará su intensidad basada en el píxel directamente debajo de él, restando un valor de decaimiento aleatorio (por ejemplo, entre 0 y 2).

Paso 1: Propagación Inicial

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[35, 35, 34, 34, 35]  <-- (36 - decaimiento aleatorio)
[36, 36, 36, 36, 36]

Paso 2: Propagación Siguiente

[ 0,  0,  0,  0,  0]
[ 0,  0,  0,  0,  0]
[34, 34, 32, 32, 34]  <-- (35 - decaimiento aleatorio)
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

Paso 3: Propagación Continua

[ 0,  0,  0,  0,  0]
[32, 32, 30, 30, 32]  <-- (34 - decaimiento aleatorio)
[34, 34, 32, 32, 34]
[35, 35, 34, 34, 35]
[36, 36, 36, 36, 36]

En cada paso, el valor de decaimiento aleatorio ayuda a simular el enfriamiento y la variabilidad del fuego a medida que asciende por la cuadrícula.

3. Paleta de Colores: Una paleta de colores cuidadosamente elegida proporciona un gradiente suave de colores fríos a calientes, mejorando el atractivo visual del fuego, por lo que aquí puedes jugar con los valores del array de colores, para crear un efecto fuego más tradicional o bien tirando a colores verdosos o azulados.

Otros Proyectos e Ideas

Además de la simulación de fuego, exploraremos otros proyectos de programación creativa, incluyendo:

1. Sistemas de Partículas: Creación de patrones y animaciones fascinantes utilizando partículas con diversos comportamientos e interacciones.
2. Arte Generativo: Exploración de técnicas de generación de arte algorítmico para crear diseños intrincados y hermosos.
3. Visualizaciones Interactivas: Desarrollo de arte visual interactivo que responda a las entradas del usuario en tiempo real.
4. Generación de Fractales: Implementación de algoritmos fractales para generar patrones complejos y auto-similares.
5. Visualizaciones de Sonido: Visualización de datos de audio de formas creativas para producir gráficos audio-reactivos impresionantes.
6. Simulaciones Físicas: Simulación de fenómenos físicos como la dinámica de fluidos, la gravedad y las colisiones con fines artísticos.

La programación creativa es una forma emocionante de combinar la programación con la expresión artística. Usando Rust y ggez, podemos crear proyectos visualmente impresionantes y altamente interactivos. Espero que esta serie de proyectos te inspire a explorar y experimentar con la programación creativa en Rust.

Os dejo el enlace al codigo completo en mi repositorio de Github desde aquí.

¡Mantente atento a futuros proyectos y sigue creando!

¡Gracias por leer! Si tienes alguna pregunta o sugerencia, no dudes en dejar un comentario. ¡Feliz codificación!