martes, 30 de junio de 2015

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

lunes, 29 de junio de 2015

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


domingo, 28 de junio de 2015

Structructure synth - para diseño 3D - 2 (renderizar con Sunflow)

El post anterio vimos como renderizar una imagen desde Structure synth, algunas formas básicas y como posicionarlas en el espacio.

Ver tutorial anterior

Vamos a ver un poco mejor esas formas y como ponerles color, y para terminar renderizar con otro programa: Sunflow

Pir ahora rederizaremos con el raytrace de structure synth  Render > Raytrace (Final)

Vamos a crear una línea de cubos separados a una distancia igual al lado de los cubos.

________________
Box
{ x 2 } box
{ x 4 } box
{ x 6 } box

Esto tambien podemos escribilo así:
Box
3 * { x 2 } box


 Vamos a ponerle un color:
______________________-
Box
3 * { x 2 color blue } box

El primer cubo está en la posicion X 0 , Y 0, Z 0 y es el rojo. Los otros 3 estás en diferentes posiciones del eje X.






Vamos a añadir 3 en el eje Y de color verde y 5 en el eje Z en sentido negativo de color amarillo
____________



Box
3 * { x 2 color blue } box
3 * { y 2 color green } box
5 * { z -2 color #ff0 } box


 El color amarillo está en exadecimal simplificado (equivake a #ffff00)
no te asustes con lo de "exadecimal" puedes tener todos los códigos de color de forma visual en esta web:





Veamos un poco más sobre las formas básicas

box - genera un cubo sólido

grid - un cubo de alámbre

line - una línea a lo largo del eje X centrada en Y y plana respecto al eje Z

dot - crea un punto centrado en 0
triangle - crea un polígono personalizado. Especifique las coordenadas de la siguiente manera:
Triangle[0,0,0; 1,0,0; 0.5,0.5,0.5]

sphere -crea una esfera.

Mesh --- crea una maya  precisa más de una declaración - así como box, sphere etc. aparecen con solo declararse la maya no aparece si solo declaras una posición en el espacio.
___________________________________________
mesh
2 * { x 2 z 2 } mesh
2 * {y 2 z 2} mesh


Las camera settings las puedes añadir simplemente pulsando botón derecho del raton soble vista previa y tomado la opción Copy camera setings to EisenScript Window

como las mayas solo tienen una cara renderizable lo que se verá en la vista previa será diferente que en la renderización.




Para renderizar con un programa externo podemos ir a Export > Template Export...
Hemos de escoger como guardar y donde en función del motor que vamos a usar. En este caso podemos escoger el que viene por defecto que es Sunflow-Colored y crearemos un archivo .sc

Podemos guardar en cualquier lugar que luego recordemos.

Vamos a descargar e instalar Sunflow  http://sunflow.sourceforge.net/

Propiamente no es que instalemos  al igual que Structure Synth precisamos tener Java inslalado.
Con descargar la carpeta ya podremos usar el programa con un pequeño detalle no hay ningún punto exe.

El archivo que debemos abrir es un .bat al cual hemos de indicar donde tenemos el archivo de Java que de precisa... no es complicado.

Si abrimos el archivo sunflow.bat con el blog de notas veremos que la primera linea pone

@set javadir="c:\program files\java\jdk1.6.0"

si vas a la carpeta archivos de programa  encontraras ahi la carpeta de java solo que seguro tendrás otra versión  en mi caso era C:\Program Files\Java\jdk1.8.0_40 así que solo tienes que cambiar la versión.



Luego al clikar en el archivo sunflow.bat se abrirá el programa y solo tendras que abrir el archivo que has guardado darle render y guardar la imágen...  segun el metodó de renderizado con hubieses guardado (hay varios que comienzan con sunflow además del clored el resultado será diferente).

Por ahora con eso te basta  y si quieres más explora las opciones... yo seguiré con el tema pero pienso ir poco a poco y si buscas por tu cuenta irás seguro más rápido.