Foto-blog de Antonio Castro

Retoque fotográfico con Gimp, fotos copyleyft, licencia Creative Commons (CC-BY), fotos gratis para uso comercial con reconocimiento.

Macrofotografía abeja

Etiqueta: Animación 3D Página 1 de 3

Como hacer scrolling para créditos finales. (Tutorial avanzado)

Imagen para el scroll.

Imagen para el scroll.

La mayoría de mis tutoriales son para usuarios noveles, pero de vez en cuando me gusta incluir alguna cosilla con algo más de chicha. Este es el caso.

Trataré de explicar como se hizo el final de uno de mis vídeos.

Ignoro como harán los demás las cosas, porque en el tema de edición y producción de vídeo hay auténticas maravillas de software, pero yo me limito a usar Software Libre.

Muchas veces me apaño usando scripts propios. Eso me da mucha flexibilidad y me permite ir construyendo poco a poco una librería de recursos de software que iré compartiendo con vosotros.

Esta vez no nos vamos a conformar con añadir un scrolling. Vamos a construir un final en tres partes: Un fundido previo, un efecto 3D y un scrolling con los créditos.

1) Preparación previa al scrolling:

Mi técnica de scrolling consiste en meter todo lo que necesito para el scrolling en una imagen alargada verticalmente.

La imagen debe tener el mismo ancho que el ancho de la imagen de la película. En nuestro caso usamos HD 720p. Es decir  1280×720. Así que el ancho será 1280 pixels.

Yo he usado Gimp para eso.

Quedará como la imagen de la izquierda.

2) Fundido previo:

Tomaremos una imagen de 1280×720 recortando la parte superior. Yo usé gThumb para eso.

Guardamos esta imagen con el nombre de ‘Fin04.jpg’. Sacamos una copia que llamaremos  ‘FinAux.jpg’ y la editamos suprimendo todo excepto el título.

También tomamos la última imagen de la película y la copiamos con el nombre de ‘Fin01.jpg’. La abrimos con Gimp y cargamos ‘FinAux.jpg’. Superponemos ambas inmágenes. (Yo lo hice pasando el negro a a blanco, conviertiéndo el blanco en transparente con la opción clolores -> color a alfa y luego desde editar copie y pegué sobre ‘Fin01.jpg’ y salve con el nombre de ‘Fin02.jpg’.

La imágenes a las que acabo de referirme son estas:

Fin01

Fin01.jpg

Fin02

Fin02.jpg

Fin04

Fin04.jpg

FinAux

FinAux.jpg

(No existe ninguna imagen ‘Fin03.jpg’ porque decidí  no incluirla en el fundido y la renombré como ‘FinAux.jpg’)

Ahora para hacer una transición fundiendo secuencialmente estas imágenes ejecuto un script muy sencillito que hace uso de la opción ‘-morph‘ de la utilidad ‘convert’ de ‘ImageMagick’ de la que hemos hablado en otras ocasiones.

Nos genera un directorio con los fotogramas. Estos pueden compilarse usando la utilidad ‘ffmpeg’. (Yo uso un script propio ‘dirs2vid.py’ del que ya hablaré en otra ocasión y que es muy similar a otro que ya mencioné como ‘dir2avi.py‘ descrito aquí.)

#!/bin/bash
rm -fr morph 2> /dev/null
rm morph.avi 2> /dev/null
mkdir morph
convert -morph 25 Fin0?.jpg morph/FIN%04d.JPG
dirs2vid.py -exif -out=FIN.avi morph

Con esto ya tenemos el fundido.

3) Preparar un bonito efecto de explosión invertida en 3D para nuestro logo:

Esto obviamente es una filigrana opcional, pero dar al logo una presentación variada es una idea que permite aumentar la atención sobre él y con esta costumbre iremos reforzando la imagen de la marca de nuestro sitio. Uno de los sitios que practica esta idea es Google a pesar de que ya tiene una imagen de marca potente.

Para ello recurrimos al trazador de rayos PovRay del cual ya hemos tratado ampliamente en otros artículos. Para no extendernos me limito a copiar el fuente.

[…]

Vemos cerca del final dentro de la cláusula object un #include «Explode.inc» Que llama al fichero que realiza la explosión de objetos.

Este include se proporciona como una utilidad para PovRay. Su autor es Chris Colefax. ‘OBJECT EXPLODER INCLUDE FILE for Persistence of Vision 3.x’

Usando nuestro lanzador PovRay usaríamos el comando:

pov.py Logo3_ j 11 11 1 500 0 4

Esto generará 500 fotogramas (‘Logo3_001.jpg’ … ‘Logo3_500.jpg’) haciendo variar el valor de clock entre 0 y 4.

Dado que en el fuente Povray hemos omitido el fondo, este aparecerá en negro.

Podemos obtener fotogramas en png con el fondo transparente reconvirtiendo esos fichros con mogrify de ImageMagick.

mogrify -format png -transparent black Logo3_???.jpg

De esa forma ya queda preparado para poder superponer esos fotogramas con fondo transparente sobre los fotogramas de nuestro scrolling. Para ello hacemos un script que genere el scrolling del texto y que superonga los fotogramas 3D que hemos generado en los fotogramas finales de nuestro scrolling.

#!/usr/bin/python
# -*- coding: latin1 -*-
import os, sys
################
def comando(comm):
print comm
os.system(comm)
######## MAIN ##########
comando ("mkdir fot1 fot2")
Top=1501
Ini3D=650
for n in range(1,Top):
comando("convert scroll.jpg -crop 1280x720+0+%d fot1/%04d.jpg" % (n, n))
m=0
# Añadir logo 3D
for n in range(1, Top):
if (n

Para finalizar juntamos el primer fundido con el vídeo de scroll que acabamos de generar ahora y ya está completo.
Puedes ver a continuación uno de los fotogramas generados.

Un fotograma del final del scrolling.

Un fotograma del final del scrolling.

El resultado completo puede verse en los créditos, al final del vídeo, de  LasVentas TML Noct 2011.

Animación de engranajes en Povray (Tutorial)

Sobre animación de maquinaria con engranajes en Povray, no he localizado nada en Internet. Lo más parecido que encontré fue sobre animación de objetos articulados.

Podría pensarse que el caso de hacer una animación con engranajes es más o menos parecido a las animaciones con objetos articulados, pero tiene algunas peculiaridades así que me he animado a hacer un tutorial sencillito.

Asumiremos que como mínimo ya tiene ciertos conocimientos, o en su defecto ya ha leído Povray conceptos básicos de animacion. (Tutorial)

En general se puede afirmar que animar un sistema de engranajes se trata de un problema más sencillo que la animación de objetos articulados. Comparte el hecho de que el movimiento de un objeto transmite movimiento a otro objeto que está ligado a él, pero la similitud termina aquí.

El problema de los engranajes necesita transformaciones más simples. Nosotros hemos buscado ilustrar una animación con un ejemplo muy sencillo y fácil de entender.

Por simplificar y hacerlo más didáctico:

  • No se incluye otra cosa que el suelo y los engranajes.
  • Todos los engranajes tienen un diseño muy simple.
  • Todos los dientes de todos los engranajes son piezas de idéntico diseño y tamaño.
  • No hay engranajes dobles compartiendo un mismo eje.
  • No se recurre a la librería de Povray ‘transforms.inc’.
  • Se hace todo en base a Macros propias bastante sencillas.
  • No se hizo uso de ningún modelador.

Dado que el número de dientes de un engranaje en nuestro ejemplo (con todos los dientes iguales) determinará la longitud de la circunferencia, podemos afirmar lo siguiente:

La velocidad de rotación (velocidad angular) de dos engranajes directamente conectados entre sí, será inversamente proporcional la cantidad de dientes de cada uno de ellos.

Aplicando esta regla, la animación del conjunto resultará sencilla.

El cálculo de la ubicación de cada engranaje ha de hacerse teniendo en cuenta sus dimensiones para que el conjunto engrane con la necesaria precisión.

Hemos añadido una pequeña marca cerca del eje a cada engranaje para que se aprecie en la animación las velocidades relativas.

Dada su sencillez, la animación quedaba un poco sosa, por ello, hemos colocado dos puntos de iluminación, hemos hecho que la cámara gire volando al rededor del conjunto, y hemos usado una textura de mármol rojo. El vídeo dura sólo 20 segundos.

El código fuente es de libre distribución y copia bajo licencia GPL y está ampliamente comentado para hacer que sea lo más legible posible.

Como de costumbre usamos nuestro lanzador pov.py y generamos 500 fotogramas con valores de clock que irán de 1 a 7200.

// Hercules.pov
// (C) Antonio Castro Snurmacher
// Licencia GPL de GNU
// 1) rm -f engranaje*.png
// 2) pov.py engranaje n 11 11 1 500 1 7200
// 3) ffmpeg -f image2 -i engranaje%03d.png -sameq -y engranage.avi
#include "colors.inc"
#include "textures.inc"
#include "shapes.inc"
#include "stones.inc"
#declare Clock20=clock/20;
#declare Clock05=-clock/70;
#declare Luz1=light_source { <-60, 70, 80> color Gray70 }
#declare Luz2=light_source { <20, 70, 20> color Gray50 }
#declare Camera00= camera {
location <50, 30, 0>
look_at <-4, 2, 2>
angle 29
// AspectRatio debe declararse en el '.ini'
// Su valor es el ancho/alto y normalmente valdrá 16/9 o 4/3
right AspectRatio*x
//rotate Clock05
rotate <0,Clock05,0>
}
#declare Epsil=.000000001; // Un tamaño arbitrario muy pequeño.
#declare Metal1 = texture {
pigment {Gray70}
finish { ambient 0.2 diffuse 0.65 reflection 0.15 phong 0.7 phong_size 7 }
}
#declare Suelo2= plane { y, -1.5
texture {T_Stone21}
scale 8
}
/************************************************************
Construye el diente de un engranaje diente con las proporciones
de un cubo unitario en <0,0,0> (box{-.5,+.5})
Rad: Radio de curvatura del biselado. (En este ejemplo se usa siempre 1.7)
Escala: Dimensiones del diente.
RadEngr: Radio del engranaje.
Rot: rotación.
**************************************************************/
#macro Diente(Rad, Escala, RadEngr, Rot)
#local DX=.12; // Desplazamiento para el biselado (0..0.2)
object{
intersection{
box{-.5,+.5}
sphere{<-Rad+DX+.5,0,.5>, Rad}
sphere{< Rad-DX-.5,0,.5>, Rad}
}
scale Escala
translate <0,0,-RadEngr>
rotate <0,-Rot,0>
}
#end
/*******************************************************************
Calcula el tamaño del diente en funcio del radio del engranaje y del número de dientes.
Explicación. Divide la circunferencia (2*pi*r) por la circunferencia (2*NumDientes).
NumDientes: Número de dientes.
Rad: Radio del engranaje.
*******************************************************************/
#macro EscalaDiente(NumDientes, Rad)
pi*Rad/NumDientes;
#end
/********************************
Dispone los dientes formando un círculo.
Rad: Radio del engranaje.
NumDientes: Número de dientes.
LonjitudEje: Espesor del engranaje.
*******************************/
#macro Dentadura(Rad, NumDientes, BiselDiente, LongitudEje)
#local AngIncr= 360/NumDientes;
#local Ang=0;
#local EscalaXZ=EscalaDiente(NumDientes, Rad);
#local Escala=;
#while (Ang<360) Diente(BiselDiente, Escala, Rad, Ang) #local Ang=Ang+AngIncr; #end #end /***************************** Construye la forma de un engranaje. Rad: Radio del engranaje. NumDientes: Número de dientes. LonjitudEje: Espesor del engranaje. RadInterior: Radio del hueco central. ******************************/ #macro Engranaje(Rad, NumDientes, BiselDiente, LonjitudEje, RadInterior) #local EscalaXZ=EscalaDiente(NumDientes, Rad); difference{ union{ // Formas que suman. Dentadura(Rad, NumDientes, BiselDiente, LonjitudEje) cylinder {<0,-LonjitudEje/2,0><0,LonjitudEje/2,0>,Rad-(EscalaXZ*0.48)}
}
union{ // Formas que restan.
cylinder {<0,-Epsil-LonjitudEje/2,0><0,Epsil+LonjitudEje/2,0>,RadInterior}
sphere {,RadInterior/4}
}
}
#end
/**************************************************************
Devuelve el radio de un engranaje en función del número de dientes y su grosor.
NumDientes: Número de dientes
***************************************************************/
#macro RadioEngranaje(NumDientes, GrosorDiente)
#local Circunferencia= GrosorDiente*2*NumDientes;
#local Radio=Circunferencia/(2*pi);
Radio
#end
/*******************************************************************
Crea el engranaje como objeto y le aplica una rotación en funcion de clock (Clock20)
Asume un tipo de diente y un tipo de engranaje
NumDientes: Numero de dientes
Desfase: Es un valor para hacer coincidir los dientes de un engranaje con su engranaje
vecino y tomará los valores 0 o 0.5.
VRot: Velocidad de rotación.
********************************************************************/
#macro ObjEngranaje(NumDientes, Desfase, VRot)
#local BiselDiente=1.7;
// El tamaño de los dientes debe de ser contante para engranar bien unos con otros
#local GrosorDiente=EscalaDiente(20, 4);
#local GrosorEngranajes=1.5;
#local RadInterior=.5;
#local Rad=RadioEngranaje(NumDientes, GrosorDiente);
object{
Engranaje(Rad, NumDientes, BiselDiente, GrosorEngranajes, RadInterior)
rotate <0,(360/NumDientes)*Desfase+(Clock20*VRot),0>
}
#end
/**************************************************************/
/**************************************************************/
camera {Camera00}
Suelo2
Luz1
Luz2
/*** El tamaño de los dientes debe de ser contante para engranar bien ***/
#declare GrosorDiente=EscalaDiente(20, 4);
#declare GrosorEngranajes=1.5;
#declare NumDient1=20;
#declare NumDient2=26;
#declare NumDient3=18;
#declare NumDient4=14;
#declare NumDient5=10;
#declare NumDient6=8;
#declare NumDient7=40;
#declare Rad1=RadioEngranaje(NumDient1, GrosorDiente);
#declare Rad2=RadioEngranaje(NumDient2, GrosorDiente);
#declare Rad3=RadioEngranaje(NumDient3, GrosorDiente);
#declare Rad4=RadioEngranaje(NumDient4, GrosorDiente);
#declare Rad5=RadioEngranaje(NumDient5, GrosorDiente);
#declare Rad6=RadioEngranaje(NumDient6, GrosorDiente);
#declare Rad7=RadioEngranaje(NumDient7, GrosorDiente);
/*** Sistema de 7 engranajes. ***/
object{
union{
ObjEngranaje(NumDient1,0, -1 )
object{
ObjEngranaje(NumDient2,.5, NumDient1/NumDient2)
translate <0,0,Rad1+Rad2>
}
object{
ObjEngranaje(NumDient3,.5, NumDient1/NumDient3)
translate <0,0,-Rad1-Rad3>
}
object{
ObjEngranaje(NumDient4,0, NumDient1/NumDient4)
translate <-Rad1-Rad4,0,0>
}
object{
ObjEngranaje(NumDient5,0, NumDient1/NumDient5)
translate
}
object{
ObjEngranaje(NumDient6,.5, (NumDient1/NumDient4)*(-NumDient4/NumDient6))
translate <-Rad1-Rad4,0,Rad4+Rad6>
}
object{
ObjEngranaje(NumDient7,0, (NumDient1/NumDient4)*(-NumDient4/NumDient7))
rotate z*-90
translate <-Rad1-Rad4-Rad4-GrosorEngranajes*.45, Rad7+(GrosorEngranajes*.3),0>
}
}
texture{Metal1}
}

‘Exploración espacial’ (parte 4): La nave.

En esta ocasión hemos procurado que el artículo ofrezca un vídeo más interesante. Para ello hemos diseñado una nave sencilla pero completita. En mi humilde opinión bastante chula dentro de su sencillez.

El diseño:
Necesitábamos que tuviera el aspecto de una nave acrobática muy manejable. Para ello no puede ser muy alargada.
No hemos recurrido a usar ninguna nave prediseñada. Hay algunas muy buenas y disponibles bajo licencia LGPL. Esta que yo aporto también se ofrece bajo licencia LGPL para que se pueda usar y modificar (siempre bajo LGPL). Continuamos sin recurrir a usar ningún modelador por coherencia con el resto del artículo y porque vi muy claro lo que quería hacer y no me pareció difícil.

El cuerpo principal:
Empecé partiendo de una esfera. La aplasté (plafch), la estiré (ñiiiak), la pegué un hachazo en la parte de atrás (chas), y rebañé un poco la panza para facilitar que se pueda posar. Con todo esto ya tenía forma básica del fuselaje a falta de dos potentes propulsores.

Los reactores principales:
Construí un par de propulsores a reacción simplemente sumando y restando formas cilíndricas y esféricas. Las toberas en la parte de atrás del reactor se han realizado con una esfera a la cual se la ha eliminado con el operador diferencia otra esfera de idéntico tamaño y un poco desplazada. No hemos implementado articulación en las toberas, pero la idea del diseño para que la nave pueda ser maniobrable es que las toberas de los reactores principales tuvieran el juego suficiente para permitir girar en horizontal y en vertical a la nave.

Los reactores secundarios:
En la panza instalé cuatro propulsores fijos para despegue vertical. Por simplificar me basé en el reactor anterior, lo giré y lo reduje de tamaño eliminando también las partes superfluas que quedarían dentro de la nave.

Los patines:
También en la panza instalé unos patines para apoyar en caso necesario sobre el terreno, salvando de un posible las toberas los cuatro reactores de despegue vertical.

Remate trasero:
En la parte posterior una simple caja me sirve para hacer que el tajo posterior a la nave no resulte tan exagerado y para insinuar una posible via de entrada a la nave suficientemente ampila para carga y descarga. Está todo sin detallar demasiado porque para este proyecto no hace mucha falta. En la parte superior trasera añadí un par de antenas blancas.

Las ventanillas delanteras:
En la parte delantera se ha diseñado unas ventanillas que simulan ser cristales tintados muy oscuros. Con ello nos evitamos tener que dar detalle a un interior de la nave que fuera visible a través de las ventanillas. Primero hice una ventanilla única recortando el fuselaje con un sólo bloque box, pero vi que no quedaba convincente, así que hice cuatro bloques para que se recortaran cuatro ventanillas y quedó perfecto.

Mi receta para modelar objetos compuestos:
Las formas complejas que tienen una misma textura y color, suelo trabajarlas fijándome en las partes que suman y en las que restan. Construyo una forma por unión de varias formas más sencillas a la cual le resto otra forma que es otra unión de varias formas más sencillas. Por decirlo de alguna manera una de las aportan material y las otras la eliminan. Luego suele ser necesario añadir otras partes que no van con la misma textura y forma.

Unas palabritas sobre macros:
No habíamos comentado hasta ahora nada sobre macros pese a que usamos algunas macros que Povray proporciona. Ahora nosotros definimos algunos objetos con macros. No debes sentirte intimidado por ellas. Aprende a usarlas, son muy potentes. Una declaración normal de las que habitualmente usamos con la sentencia ‘#declare’ asocia a un identificador un código que será expandido cuando el intérprete de Povray se lo encuentre.  Una macro viene a ser una declaración más, como cualquier otra, pero que no tiene definidos algunos valores que deben ser proporcionados. Recibe unos argumentos y en el momento que es invocada provoca toda la expansión del código declarado, sustituyendo así a los parámetros por sus valores. Además admite el uso de declaraciones locales sólo visibles para la macro. Gracias a eso se pueden usar como si fueran funciones de librería.

El programa de demo:
He realizado un programa pov que permite ver la nave desde casi todos los puntos de vista. Ello se hizo así con el fin de que se aprecie con todo detalle como está realizada integramente la nave. Se ha englobado todo ello en un recinto esférico con una decoración que nos permitirá apreciar el efecto de iluminacion de los faros, y el reflejo en la ventanilla de la nave.

Las luces laterales tienen un color más amarillento, no por nada, sino por aportar algo de originalidad al diseño. No me resulta fácil justificar la ventaja funcional de usar distintos colores en los faros, pero así lo dejaré porque me gusta como queda.

#include "colors.inc"
#include "nave_luz.inc"
#declare ColorLuz   = rgb <0.7, 0.7, 0.7>;
#declare ColorMap = color_map {
    [0.0  color rgb <0.1,0,0.1>]
    [0.02  color <0.3,0.2,0.2>]
    [0.15  color <0.5, 0.4, 0.3>]
    [1.0  color <0.6, 0.4, 0.6>]
}

#declare Crackle = texture {
    pigment {  crackle
        color_map { ColorMap }
        scale 20
    }
}

object {sphere {<0,10,0> 66 texture {Crackle} } }
light_source{ <0, 4+(clock/30),60> ColorLuz} // La luz se mueve.
camera { // la cámara se mueve en elevación (en Y)
               // y alejandose y volviendose a acercar (en Z)
    location <0,-10+(clock/20.0), 6+sin((clock-120)/27)>
    look_at <0,0,0>
    angle 29
}

object {Nave rotate y*(clock-120) } // la nave gira sobre su eje.

El código de la nave:
La nave se ha implementado de forma separada en un include para poder ser utilizado por otros porgramas.

#declare PinturaNave= Gray90;
#declare PinturaPatin= Gray60;
// **************************************************
#declare Reactor=union { // Reactores princilales
    difference {
        union{  // *** Aqui las partes que suman todas con misma textura color, etc.
            sphere {<0.3,0,0>, 0.2}
            sphere {<-0.78,0,0>, 0.25}
            cylinder {<0.3,0,0>,<-0.6,0,0>, 0.18}
        }
        union{ // *** Aquí las partes que restan
            cylinder {<0.3,0,0>,<-1,0,0>, 0.12}
            sphere {<-0.8,0,0>, 0.25}
        }
        pigment {PinturaNave}
    }
     object{ // Superficie blanca para simular fuente de luz mediante una luz cercana.
            cylinder {<-0.6001,0,0>,<-0.6002,0,0>, 0.18}
            pigment { White }
     }
     light_source{ <-0.62,0,0> color White // Luz del reactor
     fade_distance 0.3 // Distancia de atenuación
     fade_power 2 // atenuación exponencial
}
}

// **************************************************
#declare Reactor2=union{ // Reactores pequeños para despegue vertical
    difference {
        union{  // *** Aqui las partes que suman todas con misma textura color, etc.
            cylinder {<0,0,0>,<-0.6,0,0>, 0.18}
            sphere {<-0.78,0,0>, 0.25}
        }
        union{ // *** Aquí las partes que restan
            cylinder {<0,0,0>,<-1,0,0>, 0.15}
            sphere {<-0.8,0,0>, 0.25}
        }
    }
    light_source{ <-0.62,0,0> color White // Luz del reactor
        fade_distance 0.2 // Distancia de atenuación
        fade_power 2 // atenuación exponencial
    }
    pigment {PinturaNave}
    rotate z*90
    scale 0.38
}

// **********************
#declare Patin= object {
    union {
        torus { 0.14, 0.032 }
        cone {<0,0,0.14>, 0.04 <0,0,-0.14>, 0.12}
    }
    pigment {PinturaPatin}
    rotate x*90
    translate <0,-0.16,0>
}

// *******************************************
// ** Define un faro con una potencia de luz
// ** y un ángulo de luz
// *******************************************
#macro Faro (ColorLuzFaro, RadFaro)
    #local Fall=RadFaro*3;  // Radio de falloff
    #local P_Trasero   =<-0.05,-0.12,0> ; // Punto trasero del foco
    #local P_Delantero =< 0.05,-0.12,0> ; // Punto delantero del foco
    #local P_Luz       =< 0.1,-0.12,0>; // Un poco más alante del faro
    union {
        object { // El faro es un tronco de cono sólido.
            cone { P_Trasero , 0.04 P_Delantero, 0.055 }
            pigment {White}
        }
        light_source{ P_Luz // Luz de proximidad al foco.
            color ColorLuzFaro*.5
            fade_distance 0.3 // Distancia de atenuación
            fade_power 2 // atenuación exponencial
        }
        object {
            light_source { <0,0,0> ColorLuzFaro // ¡OJO!  No podemos poner aquí P_Luz antes de girar.
                spotlight point_at (P_Delantero - P_Trasero) // Apuntar en la dirección que apunta el faro.
                radius RadFaro falloff Fall
            }
            translate P_Luz
        }
}
#end

// ******************************************
// ** Fabrica un faro triple.
// ******************************************
#macro TripleFaro(ColorLateral, ColorCentral)
    union {
        object {Faro(ColorLateral, 4) rotate y*(16) translate <-0.03, 0,  -0.14>}
        object {Faro(ColorCentral,4.5)}
        object {Faro(ColorLateral,  4) rotate y* (-16) translate <-0.03, 0, 0.14>}
     }
#end

// **************************************************
#declare SepVent= 0.02;
#declare BoxVentanilla = union{
    box {<1,0.52,-1>            <0.7,0.3,-0.3-SepVent>  }
    box {<1,0.52,-0.3+SepVent>  <0.7,0.3,    -SepVent>  }
    box {<1,0.52, SepVent>      <0.7,0.3, 0.3-SepVent>  }
    box {<1,0.52,0.3+SepVent>   <0.7,0.3,           1>  }
}

// **************************************************************
#declare CuerpoNave= object {
    difference{ // Cuerpo principal
        union { // *** Aqui las partes que suman todas con misma textura color, etc.
            sphere {<0,0,0> 1}
        }
        union{ // *** Aquí las partes que restan
            box {BoxVentanilla} // hueco
            box {<-0.2,1,1> <-1,-1,-1> } // corte trasero
            box {<1,-0.5,1> <-1,-1,-1> } // corte panza
        }
    }
    pigment {PinturaNave}
    scale <2,0.3,1>
}

// **************************************************
#declare Ventanilla = object {
    intersection{ // Cabina cristal tintado (realmente es opaco)
        sphere {<0,0,0> 1}
        box {BoxVentanilla}
    }
    pigment {Gray20} // casi negra
    finish { reflection {0.4} phong 0.7 phong_size 7 }
    scale <2,0.3,1>
}

// **************************************************
#declare PuertaDeCarga = object {
    box {<-0.4, 0.2, 0.4>, <-0.6, -0.1, -0.4>}
    pigment {PinturaNave}
}

// **************************************************
#declare Antenas = object{
    union {
        cylinder {<.3,0, 0.4>,<-0.4,.4,0.4>,0.02 }   // *** antena
        cylinder {<.3,0,-0.4>,<-0.4,.4,-0.4>,0.02 }   // *** antena
    }
    pigment {White}
}

// ****************************************************************
// ************************   N A V E  ********************************
// ****************************************************************
#declare ColorFaroCentral= rgb <0.8, 0.8, 1>;
#declare ColorFaroLateral= rgb <0.8, 0.8, 0.4>;
#declare Nave = object {
    union {
        object{CuerpoNave}
        object{Ventanilla}
        object{Antenas}
        object{TripleFaro(Orange, White) translate<1.87,0,0>}
        object{PuertaDeCarga}
        object{Reactor translate<0, 0.05, -0.75> }
        object{Reactor translate<0, 0.05, 0.75> }
        object{Reactor2 translate<0, 0.07, 0.6> }
        object{Reactor2 translate<0, 0.07, -0.6> }
        object{Reactor2 translate<1.1, 0.07, -0.5> }
        object{Reactor2 translate<1.1, 0.07,  0.5> }
        object{Patin translate <-0.2, 0, 0.75>} // 0.6>
        object{Patin translate <-0.2, 0, -0.75>}
        object{Patin translate <1.3,0, 0.35>}
        object{Patin translate <1.3,0, -0.35>}	// -0.4>
    }
    translate <-0.33,0,0> // trasladamos para adelantar el centro del objeto
}

Página 1 de 3

Funciona con WordPress & Tema de Anders Norén