Mostrando entradas con la etiqueta structure Synth. Mostrar todas las entradas
Mostrando entradas con la etiqueta structure Synth. Mostrar todas las entradas

martes, 23 de noviembre de 2010

Más animaciones

Hoy solo colorinchos y código de Structure Synth.
Vídeo en: http://videobin.org/+2ks/2vh.html


Este tardó 3 horas y media en ser trazado, lo que le hace a uno cuestionarse si será válido para cosas grandes (el video muestra el bucle dos veces)

Ah, sí, antes de nada decir que al parecer se puede establecer que al alacanzar el límite de recursividad de una regla se aplique otra con:
rule <nombre de la regla> maxdepth <profundidad> > <regla que se ejecutará al final>

Introducción a Structure Synth (y van 4), animaciones con la nueva versión

Pues sí, se supone que la serie se quedaría en el 2, pero resulta que acaban de lanzar la versión 1.5 de Structure Synth, que añade:
  • Un raytracer integrado, ya no hay que usar programas externos como Sunflow
  • Scripting con Javascript para hacer animaciones (a estas alturas más de uno, entre los que me incluyo, ya debe estar salivando =D )
  • Exportación de archivos OBJ (confieso que esto aún no se que es)
  • Cambios varios... en la GUI, se añadio un generador de números aleatorios para el preprocesador, etc
Y uno no se puede quedar sin hablar de ella =P
La nueva versión se puede descargar aquí: http://structuresynth.sourceforge.net/download.php

Empezamos...

martes, 7 de septiembre de 2010

Introducción a Structure Synth (y III), el regreso

Gracias a Vishkey, descubrí hace un tiempo que las posibilidades que brinda Structure Synth van más allá de lo mencionado anteriormente, pues resulta que también soporta texturas más complejas, siempre partiendo de las mismas figuras básicas, cuales son dependen de la plantilla usada para exportar, como la plantilla "Sunflow-Ultimate-Groovelock", que como se encuentra entre las que están por defecto, servirá de ejemplo.

La sintaxis es la siguiente:

<figura base>::<textura>



Así, si queremos hacer una esfera con una textura de cristal ("glass"), haremos


sphere::glass



Este ejemplo muestra brevemente como se ven las texturas

set background black
{color white x -0.50005 s 0.001 1000 1000}box::ao // Base
{color white }sphere::glass
{color white x 10 s 0.5 1000 1000}box::shiny // Luz/techo
{ color blue y -2 }sphere::diffuse
{ color white y -4 } sphere::mirror
{color red y -6 } sphere::ao
{color black y -8 }sphere::constant
{color white y -10} sphere::phong
{color white y -12} sphere::ward



De izquierda a derecha, las texturas "glass" en blanco, "diffuse" en azul,"mirror" en blanco,"ao" en rojo,"constant" en negro,"phong" y "ward" en blanco. Además hay una caja que sirve de suelo (con una textura "ao" en blanco) y otra que ilumina la escena (con una textura "shiny" también en blanco).

Este otro ejemplo, (escrito por Vishkey) muestra más claramente las posibilidades que hay

//Autor: Vishkey

{s 2} room

esferas

rule room {
{color brown}pared
{z 20} paredLuminosa
{rx 90 z 10 y 10 color green} pared
{rx 90 z -10 y 10 color blue} pared
{ry 90 z 10 x -10 color yellow} paredEspejo
{ry 90 z -10 x -10 color white} paredEspejo
}

rule esferas {
{s 2 z 1 x 2 color white} sphere::glass
{s 2 z 1 x 1 y 1 color white} sphere::mirror
{s 2 z 1 x 1 y -1 color blue} sphere::phong
{s 2 z 1 x 2 y 2 color green} sphere::ao
{s 2 z 1 x 2 y -2 color yellow} sphere::constant
{s 2 z 1 x 1 y -3} sphere::diffuse
{s 2 z 1 x 2 y -4} sphere::shiny
{s 2 z 1 x -2 y -3 color white} box::ward
{s 2 z 1 x -3 y -2 color white} box::ao
{s 2 z 1 x -2 y -1 color white} box::phong
{s 2 z 1 x -3 color white} box::glass
}

rule pared {
{s 20 20 1} box
}

rule paredLuminosa {
{s 20 20 1} box::shiny
}

rule paredEspejo {
{s 20 20 1} box::mirror
}





Como se puede ver, el resultado es una delicia para los ojos aun con pocos elementos... aunque quizá demasiado perfecto =).
Por último añadir que la plantilla usada "Ultimate-Groovelock" añade algunas luces por su cuenta (se aprecia en algunos reflejos), en caso de querer tener un control total de la imágen estas se podrían eliminar buscando las secciones light adecuadas de la plantilla y eliminándolas o cerrando la escena con cajas... es elección de cada uno.

Hasta otra.

viernes, 23 de julio de 2010

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]
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:
  1. Poner un cuadrado en el centro
  2. 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:

  1. Poner un cubo en el centro
  2. 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:
  1. Se dibuja un triangulo (la estructura externa)
  2. 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
}


Hasta la próxima.

[Referencias]
http://www.fractalforums.com/
http://structuresynth.sourceforge.net/
http://structuresynth.sourceforge.net/reference.php
http://sunflow.sourceforge.net/
http://www.fractovia.org/art/es/

lunes, 19 de julio de 2010

Introducción a Structure Synth ( I )

Nada, ya está la primera parte de esta introducción a Structure Synth, sin mas dilación...

Todos lo que se puede hacer en Structure Synth se basa en unos elementos básicos llamados reglas, las reglas básicas (llamadas primitivas) son:

  • Sphere (esfera)

  • Box (caja)


  • Grid (Rejilla)


  • Line (Línea)


 Lo único necesario para que se muestre una regla es poner su nombre en el archivo que se va a "leer", por ejemplo


Sphere

Mostraría una esfera.

Como no, este lenguaje permite comentarios multilínea, desde  /*   hasta */ y comentarios de una sola línea, poniendo // al principio del comentario, como cualquier comentario en C.

Por cierto, si estas viendo que las imágenes tienen el fondo en blanco, pero si lo haces tu no, es por que hay que añadir


set background white

Ya explicaré más tarde para que sirve, pero no afecta a la programación en si.

Transformaciones geométricas: Movimiento, Traslaciones

En este lenguaje siempre se parte del sistema de coordenadas, para mover una regla lo que hay que hacer es mover sus coordenadas a través de lo que se llaman transformaciones, estas se especifican entre '{'  '}' antes de una regla, para mover el sistema de coordenadas del eje X en 2 unidades haremos
{ x 2 } regla

Lo mismo para cualquier otro eje ('Y' o 'Z'). Así si queremos poner dos cajas separadas, haremos


Box
{ x 2 } Box

El resultado es este:


Hay que recordar que las transformaciones solo se aplican para esa regla en concreto, las nuevas reglas seguirán partiendo del sistema de coodenadas original.


Box
{ x 2 } Box
{ x 4 } Box



Esto se puede hacer pesado si se tiene que repetir muchas veces, así que se puede utilizar un bucle que lo haga, la sintaxis para hacerlo es:
<numero de veces> * { <lista de transformaciones> } <regla>

Por ejemplo, si queremos que se repita lo que hemos estado haciendo (poner cajas separadas), digamos... 10 veces, haremos:


10 * { x 2 } Box


Importante: Cada iteración del bucle parte del sistema de coordenadas de la anterior (la primera parte del original)



Por supuesto, también se pueden anidar para hacer cosas más complejas, por ejemplo:


10 * { x 2 } 10 * { y 2 } Box




Transformaciones geométricas: Rotaciones

Otro tipo de movimiento que se realiza a través de las transformaciones es el de rotación, pero como la posición inicial depende del sistema de coordenadas, lo que se hace es rotar este sistema, por ejemplo, para rotarlo sobre el eje Y ( se "moverán" los ejes 'X' y 'Z' ), especificaremos una transformación
ry <grados de rotación>
(rx o rz para los ejes 'X' y 'Z' respectivamente )

Entonces, para dibujar un circulo solo hay que poner una caja, girar el eje 'X' (rotando sobre uno de los otros dos), y avanzar sobre este eje, repitiendo esto hasta que se hayan completado los 360 grados, por ejemplo:


360 * { ry 1 x 1 } Box


Transformaciones geométricas: Cambios de tamaño

Además se puede cambiar el tamaño del sistema de coordenadas, hacerlo implica cambiar el tamaño de las figuras y la distancia que se recorrerá con los mismos valores, la transformacion es:
s <proporción del nuevo sistema de coordenadas> 

La proporcion original es 1, 2 el doble, 0.5 la mitad...
Si al ejemplo anterior se le añade esta transformación...


360 * { ry 1 x 1 s 0.995 } Box



Si se añaden más iteraciones la espiral continúa...


1080 * { ry 1 x 1 s 0.995 } Box




Transformaciones de color: Tono, saturación y brillo

Structure Synth usa un tipo de color llamado HSV (Tono, saturación y valor), en vez del RGB, esto divide los colores en 3 valores, tono, la saturación y el valor (o brillo).
Tono es el "color" que tiene: rojo, verde, azul... La saturación, que indica la cantidad de color (va de blanco a todo color). Y el valor (o el brillo), que indica la cantidad de luz (de blanco a negro).

El tono va de 0 a  360 y vuelta a empezar (361 es igual a 1), su transformación es
hue <tono> 

Para ver como funciona de una forma más grafica, volveré al ejemplo del circulo (por problemas con Structure Synth esta pasado por Sunflow) ...


360 * { ry 1 x 1 hue 1 } Box



 La saturación es una proporción (como el cambio de tamaño), la transformación es
 sat <saturación> 

Volviendo al caso de las cajas contiguas:


10 * { x 1 sat 0.8 } Box



El valor (o brillo) es también una proporción, de 1 (claro) a 0 (negro), la transformación es
b <brillo>

Siguiendo con el ejemplo de las cajas contiguas


10 * { x 1 b 0.8 } Box

 Transformaciones de color: Alfa y colores absolutos

El alfa (o alpha) es el grado de transparencia que tiene un objeto, es una proporción, de opaco a totalmente transparente, la transformación es
 a <transparencia>

Si seguimos con las cajas...


10 * { x 1 a 0.8 } Box



 Por último decir que Structure Synth permite usar colores absolutos con la transformación
  color <color>

Los colores pueden ser RGB (rojo: #FF0000, verde: #0000FF ...) y los colores predefinidos de SVG (red, lightred, blue, gray ...)

Parámetros y preprocesador

Structure Synth se basa en unos parámetros para definir el "límite" de lo que se renderizará (ahora puede que no parezca muy lógico, pero con recursividad lo será), estos parámetros se especifican con:

set maxdepth <limite>      // Número máximo de generaciónes (iteraciónes o recursividad) antes de acabar
set maxobjects <limite>      // Número máximo de objetos antes de acabar
set minsize <limite>      // Tamaño mínimo de los objetos que se mostrarán antes de acabar
set maxsize <limite>      // Tamaño máximo de los objetos que se mostrarán antes de acabar
set background <color>      // Color de fondo (en RGB o con las palabras clave de SVG)

El preprocesador sirve para definir constantes de la misma forma que se hace en C, no tiene ninguna dificultad...
#define nombre_de_la_constante constante



Mezclando un poco de todo...


1080 * { ry 1 x 1 hue 1 s 0.997 } Box




Eso es todo por ahora, con el próximo más y mejor: definir nuevas reglas, recursividad, fractales, aleatoriedad...

Hasta entonces