Código para llevar: Introducción a Structure Synth ( y II )

Bien, seguimos con Structure Synth...

Definición de nuevas reglas

Recordemos que la unidad básica de los scripts de Structure Synth son las reglas (y las reglas más básicas las primitivas), así que existe la posibilidad de definir nuestras propias reglas, esto se hace sencillamente haciendo:

rule <nombre de la regla> {
componentes de la regla
}

Es decir, para hacer una figura similar a una casa (hay que echarle algo de imaginación),se podria hacer

Box
{ x 0.5 ry 45 s 0.75 } Box

Si se utilizase esta forma varias veces, se podria definir una regla que la construyese directamente:

rule casa{
Box
{ x 0.5 ry 45 s 0.75 } Box
}

Aleatoriedad

Además, si se define una misma regla varias veces, se escojera una aleatoria entre las definidas, por ejemplo, si definimos

rule micaja{
{ color blue } Box
}

rule micaja {
{ color red } Box
}

Cada vez que llamemos a micaja, obtendremos una caja de color azul o rojo, escogida al azar, por ejemplo:

10 * { x 1 } 10 * { y 1 } micaja

Se puede cambiar la probabilidad de que salga una regla cualquiera simplemente haciendo

rule <nombre de la regla> weigth <probabilidad de la regla> {
componentes de la regla
}

La probabilidad por defecto es 1, si es 2, hay el doble de posibilidades, con 0.5, la mitad...

Recursividad

Por supuesto, una regla puede llamarse a si misma (recursividad), en estos casos hay que tener en cuenta el parámetro maxdepth (set maxdepth <valor>) que especifica la profundidad máxima que puede alcanzar la recursión.
La recursividad no requiere ningun truco, simplemente se llama a la propia regla como se llamaría a cualquier otra, por ejemplo, si recordamos el código de la espiral:

360 * { ry 1 x 1 s 0.995 } Box

Este se puede pasar a recursivo simplemente llamando a la figura base ( aquí Box ) y aplicando las transformaciones a la siguiente recursión:

rule espiral{
Box
{ ry 1 x 1 s 0.995 } espiral
}

espiral // Hace falta iniciar el proceso

El resultado es bastante similar, con la diferencia de que no se define un límite, sino que este depende de los parámetros.

Transformaciones geométricas: cambios de tamaño "avanzado"

Hasta ahora para cambiar el tamaño del sistema de coordenadas, lo hemos hecho con todas las dimensiones a la vez, es decir, 'X', 'Y' y 'Z' crecían en la misma proporción, con lo que, por ejemplo, un cubo (Box) era siempre un cubo perfecto, pero se puede cambiar el tamaño de las dimensiones de forma independiente, la transformación entonces es esta:
s <nueva proporción de X> <nueva proporción de Y> <nueva proporción de Z>

Esto puede parecer un lío al principio, es solo cosa de cojerle el truco, por ejemplo, si queremos una caja (Box) con 0.1 de ancho, 1 de alto, y un 1 de lado haríamos:

{ s 0.1 1 1 } Box

O, si queremos uno con 0.1 de ancho, 2 de alto, y un 0.1 de lado

{ s 0.1 2 0.1 } Box

Estas figuras pueden ser interesantes para simular líneas, que suelen tener problemas al pasarse por Sunflow, por ejemplo, para hacer un toro con ellas:

180 * { ry 2 x 0.5 hue 2 } 72 * { rx 5 rz 5 y 1 } basefig

rule basefig{
{ s 1 0.1 0.1 } box
}

Fractales
Como con logo, los fractales no pueden faltar, copio y pego la "introducción":

Un fractal es un objeto semigeométrico cuya estructura básica, fragmentada o irregular, se repite a diferentes escalas.^[1]Una mejor manera para comprender el comportamiento fractal de nuestro universo es considerar la siguiente definición: "Patrones que se repiten a distintas escalas".
A un objeto geométrico fractal se le atribuyen las siguientes características:^[2]

Es demasiado irregular para ser descrito en términos geométricos tradicionales.

Posee detalle a cualquier escala de observación.

Es autosimilar (exacta, aproximada o estadística).

Su dimensión de Hausdorff-Besicovitch es estrictamente mayor que su dimensión topológica.

Se define mediante un simple algoritmo recursivo.

Dejemos aparte todo lo de "autosimilar", "dimensiones topologicas" y demas... lo mas comprensible es que "se repite a distintas escalas" y "se define mediante un simple algoritmo recursivo", vamos a probar...

Supongamos que queremos hacer un fractal similar a una alfombra de Sierpinski, los pasos para hacerlo son:

Poner un cuadrado en el centro
Repetir el proceso a menor escala en los lados y diagonales del cuadrado

Perfectamente recursivo, ¿verdad?, además no requiere ninguna herramienta que no proporcione Structure Synth y se aplicar sencillamente a 3D:

Poner un cubo en el centro
Repetir el proceso a menor escala en los lados y diagonales del cubo

El código, que nadie se asuste que el tocho es para que se repita en cada lado, es solo copiar-pegar cambiando las distancias en 'X', 'Y' y 'Z' y el hue es para que la imágen quede más clara, con diferente color para cada nivel de recursi:

set background white
set maxdepth 5 // Profundidad máxima
#define space 3   // Espaciado entre figuras
#define ratio 0.33 // Ratio de cambio de tamaño
#define color_change 50 // Tamaño de los pasos de cambio de color

sierpinski

rule sierpinski{
    { hue color_change s ratio x space } sierpinski
    { hue color_change s ratio x -space } sierpinski

    { hue color_change s ratio y space   } sierpinski
    { hue color_change s ratio y -space } sierpinski

    { hue color_change s ratio z space   } sierpinski
    { hue color_change s ratio z -space } sierpinski

    { hue color_change s ratio x space y space                 } sierpinski
    { hue color_change s ratio x space y space z space   } sierpinski
    { hue color_change s ratio x space y space z -space } sierpinski
    { hue color_change s ratio x space y -space                } sierpinski
    { hue color_change s ratio x space y -space z space } sierpinski
    { hue color_change s ratio x space y -space z -space } sierpinski

    { hue color_change s ratio x -space y space                 } sierpinski
    { hue color_change s ratio x -space y space z space   } sierpinski
    { hue color_change s ratio x -space y space z -space } sierpinski
    { hue color_change s ratio x -space y -space    } sierpinski
    { hue color_change s ratio x -space y -space z space } sierpinski
    { hue color_change s ratio x -space y -space z -space } sierpinski

    { hue color_change s ratio y space z space   } sierpinski
    { hue color_change s ratio y space z -space } sierpinski
    { hue color_change s ratio y -space z space } sierpinski
    { hue color_change s ratio y -space z -space } sierpinski

    { hue color_change s ratio z space x space } sierpinski
    { hue color_change s ratio z space x -space } sierpinski
    { hue color_change s ratio z -space x space } sierpinski
    { hue color_change s ratio z -space x -space } sierpinski

    box
}

Pasando a algo más complicado, un triángulo de Sierpinski, extrapolado a 3D (ya se mostró el código para 2D), el proceso sería este:

Se dibuja un triangulo (la estructura externa)
Se repite el proceso a la mitad de escala en la mitad de cada diagonal

Y esto fue lo mejor que conseguí, sobre todo lo que no me gusta son tantos números que no son "redondos" :(

#define thick 0.05
#define linecolor red
#define basecolor white
set maxdepth 20

triangulo

rule triangulo {

    // Diagonales
    { color linecolor x -0.5 y 0.75 z -0.5 rx 181.7 ry 45 rz 45 s 2.1 thick thick } box
    { color linecolor x -0.5 y -0.75 z 0.5 rx 1.7 ry 45 rz 45 s 2.1 thick thick } box
    { color linecolor x -0.5 y -0.5 z -0.75 rx 91.7 ry 45 rz 45 s 2.1 thick thick } box
    { color linecolor x -0.5 y 0.5 z 0.75 rx 271.7 ry 45 rz 45 s 2.1 thick thick } box

    // Base
    { color basecolor x -1.025 rx 11 s 0.05 2.6 2.6} box

    // Niveles interiores

    { s 0.5 } triangulo

    { x -0.5 y 0.73 z -0.495 s 0.5 } triangulo
    { x -0.5 y -0.73 z 0.495 s 0.5 } triangulo
    { x -0.5 y -0.495 z -0.73 s 0.5 } triangulo
    { x -0.5 y 0.495 z 0.73 s 0.5 } triangulo

}

Además, hablando de fractales no pueden faltar los árboles binarios, esta vez representados en 3D (código e imágen de Vishkey), muy logrado el efecto de las "ramas" al dividirse:

set background #0066CC
{s 30 0.1 30 y -5 color #330000} box
4 *{x 2} 4 * {z 2} 1 * {rz 90} r1

rule r1 maxdepth 15 {
    c1
    {s 0.5 0.5 1 x 1.4 y 0.25 rz 30 b 100} r1
    {s 0.5 0.5 1 x 1.4 y -0.25 rz -30 b 100} r1
    {s 1 0.5 0.5 z -0.25 x 0.98 ry 30 b 100} r1
    {s 1 0.5 0.5 z 0.25 x 0.98 ry -30 b 100} r1
}

rule c1 {
    {s 1 0.05 0.05 color green} box
}

Por último... no es un fractal, pero me gustó el resultado, aunque es uno diferente cada vez que se ejecuta :P

set maxdepth 500
#define color_change 0.5

spiral

rule spiral weight 100{
    box
    { s 0.999 hue color_change ry 0.5 x 1 } spiral
}

rule spiral weight 1{
    box
    { s 0.95 hue color_change rx 180 ry 1 x 1 } spiral
    { s 0.99 hue color_change ry 1 x 1 } spiral
}

rule spiral weight 0.01{
    box
    { s 0.99 hue color_change rx 180 ry 1 x 1 } spiral
}