Como exportar de Structure Synth a Blender

Vamos a pasar de Structure Syth a Blender. Es decir vamaos a exportar de Structure Synth y con esa escusa voy a introducir a Blender.

Vamos a partir del predeterminado que ofrece el programa
Primero para ver lo que vamos a exportar vamos a pulsar el botón que pone Build. Así el programa ejecutará el código y nos mostrará una vista de la estructura que vamos a exportar.

Tambien podemos escoger algun otro de los ejemplos que nos ofrece el programa.

Para exportar vamos a  Export y escogemos Obj Export

Las opciones de exportación son si deseamos agrupar los objetos que forman la estructura por Tag Group by Tagging o por color Group by Color, podemos escoger ambos.

Eso tereminará el número de objetos que se exportarán.

También tendremos la posibilidad de escoger la resolución de las formas que componen nuestra estructura, en este caso las esferas que componen las espirales.

Voy a exportar agrupando por Tag... eso producirá dos objetos. Lo veremos una vez estemos en blender.

Una vez guardado ya no tenemos nada más que hacer en Structure Synth.

Si no tenemos Blender, evidentemente deberemos instalarlo. Es totalmente gratuíto pero no nos llevemos a engaño, es uno de los programas de 3D más completos que existen.

https://www.blender.org/

Una vez instalado lo abrimos y encontraremos lo que algunos definen como una interface aterradora.

En realidad es una interfase extremadamente flexible a la que no es difícil adaptarse con la práctica.

Interface Blender inicio

Por omisión el programa viene con un cubo. Para este ejercicio lo vamos a borrar, pero lo vamos a aprovechar para estudiar lo que luego vamos a usar con las estructuras que importaremos desde Structure Synth.

Nos encontramos en la vista de objeto Object Mode. Observa abajo a la derecha
Nos aseguramos de que tenemos seleccionado el cubo.

Para ello vamos pulsar con el botón derecho ratón RMB sobre el cubo (no recomiendo usar Blender sin un ratón completo con ruedecita). Pulsando con el ratón derecho selecionaremos los objetos.

En este caso tenemos 3 objetos - el cubo la cámara y una luz - que podemos ver en  el Outliner.

Outliner

Tambien es posible seleccionar objetos en el Ouliner, y cambiar el nombre de estos.

Si tenemos seleccionado un objeto podremos desplazalo en los 3 ejes (X, Y y Z).

Lo que vamos a hacer solo requiere de esta simple introducción.

Vamos a borrar el cubo. Par ello lo debemos tener seleccionado. Podemos pulsar la tecla X o Supr.

Y seguidamente vamos a importar la estructura - recuerden que la guardamos con extension .obj.

Vamos a File > Import > Wavefont (.obj) y vamos a donde tenemos el archivo .obj que exportamos desde Structure Synth.

En este caso exporté 3 uno con esferas a 20 de resolución y dos con las esferas a 10.

El que exporte como Group by Tag es el que importaremos, el otro es el que está  agrupado por colores. 

Pulsamos Import OBJ y ya tenemos las estructuras importadas.

Podemos ver que los colores de Structure Synth no se han importado.

Rotando la rueda del ratón podemos alejar la vista...

Si vamos al Outliner veremos que ya no está el cubo, y en cambio hay dos objetos nuevos (default y LMB del mouse o con el botón derecho RMB y escogiendo rename

shiny) que son las dos estructuras que hemos importado y que están seleccionadas.  Podriamos renombrarlas pulsando con doble click en el nombre con el botón izquierdo

Lo que vamos a hacer es pulsar sobre el nombre de una de ellas con el botón derecho RMB y escoger seleccionar (hay otro modo de seleccionar en el espacio de la vista - con la tecla A seleccionariamos todo o deseleccionariamos todo si ya está seleccionado y luego con el botón derecho RMB seleccionaríamos el objeto).

Una vez selccionada la estructura en espiral podemos darle un color (darle un material).

Cambiar material

Eso lo hacemos en el panel que hay debajo del Outliner ,  que es el panel de propiedades Properties Properties (no recomiendo cambiarle el idioma a Blender - sí se puede, pero no lo recomiendo).

Una vez en el panel de propiedades en donde se ve en la imágen, pulsamos Difuse y escogemos un color.

Luego seleccionamos la otra estructura y hacemos lo mismo escogiendo otro color.

Podriamos hacer más cosas pero esto es una mera introducción (les dejaré el vídeo tutorial que ha hecho un amigo por si desean profundizar en blender).

Lo que ahora haremos es exportar con un plugin o addon que permite crear una web con un visualizador 3D y rotar nuestra escena.

Para ello primero debemos descargarlo.
https://www.blend4web.com/en/downloads/
 Lo guardaremos pero no lo vamos a descomprimir - se guardará como un archivo comprimido -  blend4web_15_06.zip (o la versión que sea) - pero lo instalaremos sin descomprimirlo.

Una vez guardado el archivo iremos a File > User Preferences

y se nos abrirá un panel. Vamos a la pestaña Add-ons y abajo donde pone Install from file...

pulsamos para ir a donde guardamos el archivo blend4web_15_06.zip

Marcamos la pestaña del addon y le damos a Save User Settings.
Con eso ya estamos listos para usarlo.

Blend4web nos permite mucho más que simplemente exportar como lo vamos a hacer. Pero no vamos a complicarnos.

Vamos a File > Export  > Blend4web  (.html)

 

Nota - Puesto que las estructuras son muy grandes  es conveniente hacerlas más pequeñas o cambiar la configuración de la cámara o una vez exportado a html se verá mal.

Eso se hace selecionando las dos espirales y apretando la letra S y luego arrastrando el mouse con el boton izquierdo presionado podemos redimensionar los modelos - las espirales en este caso..

Structue synth -7 Mejorando el código y reflejando en los 3 ejes

Veamos como contruir un plano solo con una linea de código.

5 * { x 2 } 5 * { y 2 } box

Eso es mejor que crear una regla para la fila y otra para repetirla:

rule lineaBase

{

5 * { x 2 }box

}

5 * { y 2 } lineaBase

_________________________________________

 Si deseamos que los cubos sean planos escalamos solo ese eje 

5 * { x 2 } 5 * { y 2 s 1 1 0.1 } box

Podemos ahora crear regla que tome ese plano para crear  una copia del plano girado y construir dos paredes.
________________________
R1

rule R1{

5 * { x 2 } 5 * { y 2 s 1 1 0.1 } box

}

{rx -90 } R1

{ry 90 } R1

Ahora creamos otra versión de esta estructura pero con valores distinos y  de otro color (para distinguirla) Vamos a meter cada una de las versiones en una regla (rule paredes 1 y rule paredes 2)

rule R1{

5 * { x 2 } 5 * { y 2 s 1 1 0.1 } box

}

Rule paredes1

{

R1

{rx -90 } R1

{ry 90 } R1

}

rule paredes2{

R1

{rx 90 } R1

{ry -90 } R1

}

paredes1

{ COLOR #0F0}paredes2

 Ahora la regla paredes dos que tiene color verde ( #0f0 ) la vamos a espejar en el eje Y con la instrucción fy. y en el eje X con fx

 rule R1{

5 * { x 2 } 5 * { y 2 s 1 1 0.1 } box

}

Rule paredes1

{

R1

{rx -90 } R1

{ry 90 } R1

}

rule paredes2{

R1

{rx 90 } R1

{ry -90 } R1

}

paredes1

{ COLOR #0F0 fy fx }paredes2

Ahora colocamos paredes2 desplazandola sobre los ejes X Y y Z x -12 y -12 z -12

rule R1{

5 * { x 2 } 5 * { y 2 s 1 1 0.1 } box

}

Rule paredes1

{

R1

{rx -90 } R1

{ry 90 } R1

}

rule paredes2{

R1

{rx 90 } R1

{ry -90 } R1

}

paredes1

{ COLOR #0F0 fy fx X -12 Y -12 Z -12 }paredes2

Structure Synth - 6 Tono, Santuracion y aleatoriedad

Vamos a ver una espital como la que compone el ejemplo que Structure synth te ofrece dinicio
 _________________________________________________
 R1

rule R1 {

  { x 0.9 rz 6 ry 6 s 0.99  sat 0.99  } R1

  { s 2 } sphere

}

Como puedes ver si has seguido el curso hasta ahora,  aquí se invoca a la regla  rule antes  de declararla... sirve igual.

La regla R1 es un array con las transformaciones de una esfera sphere  que esta escalada un 200% s 2. Eso forma parte de un regla que se invoca a si misma R1 y que se desplaza 0.9 veces su tamaño en el eje X  x 0.9  rota en el eje Z 6grados rz 6   otros 6 en el eje Y ry6 y se escala un 99%  s 0.99 . El color tambien cambia en este caso de saturación.

Veamos esto de HSV o HSB  matiz o tono - hue - saturación - sat - e intensidad -  value o brigness - b .

Las variaciones de color pueden ser de matiz o  hue, saturación sat, brillo b o de alpha a.

El Alpha controla la transparencia - 1 es opaco y 0 transparente... los intermedios son los decimales.
Puedes ver eso en la imagen generada desde esta código:
_______________________
sphere

10 * { x 1 hue 50 } sphere

10 * { y 1 sat 0.7 } sphere

10 * { x -1 b 0.7 } sphere

10 * { y -1 a 0.7 } sphere

 Si añadimos una segunda que incremente en sentido contrario  y con una variacion de  tono en lugar de saturación... la llamamos R2 y otra que llamaremos R3 que además tenga invertido el valor del giro en el eje Z.                       
_________________________________________________________-
R2

rule R2 {

{ x -0.9 rz 6 ry -6 s 0.99 hue 0.99 } R2

{ s 2 } sphere

}

Vamos a darle mas recursividad invovando reglas dentro de las reglas ( en lugar de sphere ahora ponemos R2 y R1 )
__________________________________________________

R1

rule R1 {

  { x 0.9 rz 6 ry 6 s 0.99  sat 0.99  } R1

  { s 2 } sphere

}

R2

rule R2 {

{ x -0.9 rz 6 ry 6 s 0.99 hue 0.99 } R2

{ s 0.5 } R1

}

R3

rule R3 {

{ x -0.9 rz -6 ry 6 s 0.99 hue 0.99 } R3

{ s 0.2 } R2

}

Veamos la aleatoriedad.  Eso se consigue haciendo varias definiciones de la misma regla.
Las imágenes que siguen son resultado del mismo código. Cada vez que construyes la pieza sale diferente.

R1

rule R1 {

{ x 0.9 rz 6 ry 6 s 0.99 sat 0.99 } R1

{ s 2 } sphere

}

R1

rule R1 {

{ x -0.9 rz 6 ry 6 s 0.99 hue 0.99 } R1

{ s 0.5 } sphere

}

 Hay un detalle que hace la aleatoriedad muy interesante y es que no solo sale una versión diferente cada vez que armamos la pieza desde el código, sino que  cuando creamos una copia en serie cada nueva instancia del objeto es diferente. Eso es por que cuando creamos la nueva instancia el programa la contruye basandose en la regla y si es aleatoria aplica la aleatoriedad.

5 * {X 10} R1

rule R1 {

{ x 0.9 rz 6 ry 6 s 0.99 sat 0.99 } R1

{ s 2 } sphere

}

R1

rule R1 {

{ x -0.9 rz 6 ry 6 s 0.99 hue 0.99 } R1

{ s 0.5 } sphere

}

Interesante ¿no?

Structure Synth - 5 Escalado y recursividad

Vamos a ver como funciona el escaldo.
La instrucción para escalar es una s seguido del valor - si ponemos menos de uno va a disminuir  y si ponemos más aumentar sobre el tamaño original.

Vamos a escalar una esfera s 1.5 mientras la clonamos 6 veces 6 * cuatro distancias (la medida de diametro de la esfera) a lo largo del eje x x 4 y le cambiamos el color que por defeco es rojo.

_____________________________________________

set background #fff

6 * { s 1.5 color #655 x 4 } sphere

______________________________________________

set background #fff
6 * { s 1.5 ry 60 color #655} 1 * { x 4 y 2 } sphere










Vamos a reducir la distancia X a 0.5 y aumentar el numero de esferas a 20 y reducir el escalado  a 1.2

y vamos a crear una regla o módulo que llamaremos tentaculo
_______________________________________________

rule tentaculo
{
 set background #fff

20 * { s 1.2 ry 60 color #655} 1 * { x 0.5 y 3} sphere

}

tentaculo

 Ahora vamos a hacer 6 copias con un giro de 60 grados en el eje y moviendo el eje de rotación media medida en X y tres medidas en Y

______________________________________________

rule tentaculo

{

 set background #fff

20 * { s 1.2 ry 60 color #655} 1 * { x 0.5 y 3 } sphere

}

6 * { rx 30 s 0.5 } tentaculo

Ya creo que a estas alturas - si has seguido las lecciones anteriores - puedes ir identificando los cambios.
________________________________________________

rule tentaculo

{

 set background #fff

20 * { s 0.9 ry 60 color #655} 1 * { x -0.5 y 4 } sphere

}

3 * { rx 30 s 0.5 } tentaculo

Seguidamente 

vamos a crear una recursividad haciendo que el rule tentaculo se invoque a sí mismo.

 Structure synt tiene un limite que se puede modificar para evitar una recursividad infinita. _________________________________________________

rule tentaculo

{

 set background #fff

20 * { s 0.9 ry 60 color #655} 1 * { x -0.5 y 4 } sphere

3 * { x 1 ry 30 s 0.5 } tentaculo

}

3 * { rz 30 s 0.5 } tentaculo

_________________________________

rule cubo

{

 set background #fff

3 * { color #655 x -0.5 y 1 } sphere

2 * { s 0.9 x 5} sphere

6 * { x 1 ry 60 s 0.5 } cubo

3 * { rz 45 s 0.5 } cubo

}

3 * { rx 50} cubo

_______________________

Vamos a dejar solo una esfera mantener la recursividad (la llamada a la propia regla dentro de la regla) y a poner una variación de matiz de color hue al la duplicación de la esfera
__________________
rule esferas

{

 set background #fff

3 * { x -0.5 y 1 hue 36} sphere

6 * { x 1 ry 60 s 0.5 }  esferas

3 * { rz 45 s 0.5 }  esferas

}

3 * { rx 50 }  esferas

______________________

El mismo código cambiando a un cubo.

Por último volvemos al escalado. No solo podemos escalar la pieza entera, podemos escalar en los tres ejes de la pieza.

Vemos aqui un escalado al 50%  ---> 0.5

box

{ x 2 s 1 1 0.5 } box

{ x 4 s 1 0.5 1} box

{ x 6 s 0.5 1 1} box

Y esto es todo por hoy... nos vemos en la siguiente.

Structure Synth - 4 girando en el espacio

 Vamos a tomar una primitiva - una caja o box - y la vamos repetir en varios ejes con diferentes colores (puedes ver tutoriales anteriores si tienes dudas). Tutorial 1   Tutorial 2     Tutorial 3

Vamos a ver ahora como además de desplazarlos los podemos girar en los diferentes ejes:
__________________
 
box
{ry 30 color green x 2} box
{rz 30 color blue x 3} box
{rz 30 ry 30 color #555 y 3} box
{rz 30 ry 30  color #f80 y 3 x 4} box

Con rz 30 estamos girando 30 gardos es el eje Z.
 Con rx o ry haremos se marca el giro en X o Y,

Color y desplazamiento ya los meos visto en anteriores entradas,


Ahora vamos a crear una regal o módulo, en realidad viene siendo un array.
Le llamamos grupo, pero podríamos llamarle de cualquier modo.
Eso es Rule grupo { } justo vimos eso en el post anterior.
______________________________________-


rule grupo {
box
 {ry 30 color green x 2} box
 {rz 30 color blue x 3} box
 {rz 30 ry 30 color #555 y 3} box
 {rz 30 ry 30 rz 30 color #f80 y 3 x 4} box
}

 9 * { rz 40 } 1 * { x 4 } grupo

 Con 9 * estamos haciendo que se repita 9 veces lo que sigue
Con  { rz 40 } decimos que lo que sigue girará en el eje Z 40º
 Con 1 * { x 4 } decimos que el giro se produzca a una distancia de 4 unidades desde el centro.
Y finalmente eso se aplica a  grupo lo cual ya está definido con rule.

Veamos diferentes distancias del centro, cambiando el color del fondo y las primitivas, las cuales haremos esferas en lugar de cajas.

__________________________________

set background #876

rule grupo { 

 { ry 30 color #333 }sphere

 {ry 30 color black x 2} sphere

 {rz 30 color black x 3} sphere

 {rz 30 ry 30 color #000 y 3} sphere

 {rz 30 ry 30 rz 30 color #555 y 3 x 4} sphere

}

 9 * { rz 40 } 1 * { x 5 } grupo

 9 * { rz 40 } 1 * { x 3 z 4} grupo

 9 * { rz 40 } 1 * { x 2 z 8 } grupo

 9 * { rz 40 } 1 * { z 12 }grupo

Si en la segundo circulo el desplazamiento en el eje Z z 2  lo aplicamos al angulo en lugar de al eje   ->   9 * { rz 40 z 2} 1 * { x 3 } grupo
el cambio es ese circulo dejará de ser circulo y tomará forma de rosca de tornillo : 

___________________________________

set background #076

rule grupo { 

 { ry 30 color #333 }sphere

 {ry 30 color red x 2} sphere

 {rz 30 color black x 3} sphere

 {rz 30 ry 30 color #000 y 3} sphere

 {rz 30 ry 30 rz 30 color #550 y 3 x 4} sphere

}

 9 * { rz 40 } 1 * { x 5 } grupo

 9 * { rz 40 z 2} 1 * { x 3 } grupo

Así iremos avanzando instrucción por instrucción - pero si quieres avanzar  más explora los ejemplos que vienen en el programa- mi idea es que puedas ir capacitandote para entender esos códicos.

Prueba de tomar una parte del código, copiarla en un archivo nuevo y modificar al menos lo que ya conoces.

Structure Synth - 3 Módulos

Vamos a ver ahora como trabajar con Módulos.
Si no entiendes este post es que te falta ver los tutoriales anteriores
 Tutorial 1   Tutorial 2  

Los modulos son grupos que podemos crear a base de primitivas, para ser llamados de lamismaq forma.

Hemos visto ya las primitivas, usaremos ahora 3 para este ejercicio.

Ponemos una caja con la instrucción box. Se colocará en el eje de coordenadas el ponto 0.
 Y 6 esferas sphere en los 3 ejes, dos en cada eje pero en sentido opuesto (una en positivo y otra en negativo) de color diferente.

para cambiar el color del fondo usaremos set background #888 (el código lo puedes obtener en https://html-color-codes.info/codigos-de-colores-hexadecimales/ )
____________
box

{ x 0.5  color blue} sphere
{ x -0.5 color blue } sphere
{ y 0.5  color green } sphere
{ y -0.5 color green } sphere
{ z 0.5  color black} sphere
{ z -0.5 color black } sphere


Para que sea un modulo le damos un nombre, por ejemplo moduloBase, lo deckaramos con rule y lo metemos entre llaves.
__________________

rule moduloBase
{
   box

{ x 0.5  color blue} sphere

{ x -0.5 color blue } sphere 

{ y 0.5  color green } sphere  

{ y -0.5 color green } sphere 

{ z 0.5  color black} sphere

{ z -0.5 color black } sphere
}

Si no lo llamamos esto nunca aparecerá en pantalla, pero ahora aparecerá con solo poner su nombre y lo podemos manejar igual que manejamos las primitivas. Podemos llamarlo antes o despues de declararlo.

Así que el código para verlo ha de ser algo así:
_______________
moduloBase

rule moduloBase
{
   box

{ x 0.5  color blue} sphere

{ x -0.5 color blue } sphere 

{ y 0.5  color green } sphere  

{ y -0.5 color green } sphere 

{ z 0.5  color black} sphere

{ z -0.5 color black } sphere
}

Ahora vamos crear una fila con esta forma tal como haciamos con las primitivas.
_________________________

rule moduloBase
{
   box

{ x 0.5  color blue} sphere

{ x -0.5 color blue } sphere 

{ y 0.5  color green } sphere  

{ y -0.5 color green } sphere 

{ z 0.5  color black} sphere

{ z -0.5 color black } sphere
}

10 * { x 2 } moduloBase

Ya estamos listos para crear otro módulo que incluya esta fila de objetos y usarlo para crear copias en el eje Y.
________________________________
set background #888

rule moduloBase
{
   box

{ x 0.5  color blue} sphere

{ x -0.5 color blue } sphere 

{ y 0.5  color green } sphere  

{ y -0.5 color green } sphere 

{ z 0.5  color black} sphere

{ z -0.5 color black } sphere 

}

rule lineaBase

{

10 * { x 2 } moduloBase

}

10 * { y 2 } lineaBase

Ya estamos listos para crear tantos Módulos como precisemos invocarlos y colocarlos en el espacio.
________________________________

 set background #888

rule moduloBase
{
   box

{ x 0.5  color blue} sphere

{ x -0.5 color blue } sphere 

{ y 0.5  color green } sphere  

{ y -0.5 color green } sphere 

{ z 0.5 color black } sphere

{ z -0.5 color black} sphere 

}

rule lineaBase

{

10 * { x 2 } moduloBase

}

rule planoY{

10 * { y 2 } lineaBase

}

rule planoZ{

10 * { Z 2 } lineaBase

}

Rule caja{

planoZ

planoY

{ z 23 } planoY

{ y 23 } planoZ

}

caja

{ z 40 } caja

{ y 40 } caja

{ x -40 } caja

{ x -40 y 40 z 40 } caja