Logo POVRay...
Instrucciones para "SRAV.inc" v1.0

Donación de Rafael Angel Campos Vargas, en marzo del 2014, a la Biblioteca de objetos de POV-Ray.  Este proyecto se encuentra actualmente suscrito a la patente LGPL;  para libre uso comercial y no comercial del software.

CC-GNU LGPL
The primary purpose of this collection is to make items publicly available under a common license that permits use, modification and re-distribution. To support this contributions are donated to the collection with consent for their use under the terms of the Creative Commons - Lesser General Purpose License (CC-GNU LGPL).
Chris Bartlett 2007
La versión actual v1.0 de "SRAV.inc" crea una serpiente de metabolas cilíndricas.  Sin embargo, es algo complicada de utilizar.  El movimiento se consigue al declarar una matriz de giros de tamaño variable.  Además, se permite la modificación de características fundamentales y de texturas mediante una macro más detallada.  Es compatible con POV-Ray 3.1.

Indice de página:

  1. Instalación de Archivos
  2. Instrucciones básicas
  3. Características del objeto
  4. Modificadores
  5. Notas y Advertencias
  6. Sugerencias de modificación
  7. Sobre LibreN3D

Instalación de Archivos

El procedimiento siguiente es completamente optativo, corresponde simplemente al estándard de la Biblioteca de objetos POV-Ray.
  1. Cree el subdirectorio "ObjectCollections".  Se sugiere un subdirectorio del folder POV-Ray, creado por el instalador en algunas versiones en la sección de documentos o bien en la de código.
  2. Copie el archivo "SRAV.inc" en dicho subdirectorio;  únicamente éste es necesario.  Opcionalmente podría colocar la documentación y demás en el mismo subdirectorio, el estándar ha sido diseñado para evitar problemas de compatibilidad.
  3. Actualice los archivos buscados por POV-Ray, en algún archivo ini pertinente.  Por ejemplo "POVRay.ini";  agregue el comando Library_Path="C:\FDOS\POVRAY31\ObjectCollections"; o el que corresponda a su sistema operativo.  POV-Ray ofrece muchas formas de realizar esto.  Si no sabe cómo, probablemente convenga leer el manual de referencia en la sección "Command-line options".   Cada sistema operativo presenta sus propias variantes.
Nota:  El archivo de prueba "SRAV.pov" puede ejecutarse sin ningún proceso de instalación.  Unicamente debería estar ubicado en el mismo folder que "SRAV.inc".


Instrucciones básicas

Serpiente
Fácil de usar, pero requiere la declaración previa de una matriz de giros.  Hecho lo anterior, es suficiente con incluir el archivo y ubicar el objeto. 

El siguiente ejemplo recurre a la macro default, colocando a la serpiente en posición base, con una matriz de giros algo trivial.

    #include "stdinc.inc"
    #include "stdcam.inc"
    #include "SRAV.inc"
                                  
    #declare MyArreglo  = array [1][5]  {{SRAV_EjeCentral,0,0,0,off}}                            
                                  
    object      {
      SRAV_Serpiente(MyArreglo,0.0) 
      translate          <-1.375,0.625,-2.5>
    }
La macro principal recibe únicamente dos parametros.
    #macro SRAV_Serpiente( MyArreglo, AvanceLengua )
MyArreglo :
Arreglo para controlar los giros. 
AvanceLengua :
Fracción entre 0.0 (adentro) y 1.0 (afuera) para sacar la lengua. 

MyArreglo es simplemente un tipo ARRAY bidimensional.  La primera dimensión es variable, y corresponde al total de giros a declarar.  La segunda dimensión contiene entre 4 o cinco campos.

    #declare MyArreglo	= ARRAY [ GirosSolicitados ][ 4/5 ]
    	{
    	  { IdentificadorGiro0, RotarX0, RotarY0, RotarZ0 [, on/off] },
    	  { IdentificadorGiro1, RotarX1, RotarY1, RotarZ1 [, on/off] },
          { IdentificadorGiro2, RotarX2, RotarY2, RotarZ2 [, on/off] }, 
    	  ...
   	} 
GirosSolicitados :
Indica el total de giros a solicitar.  El número es libre con un valor máximo de 55, es decir existen 55 puntos de control.
IdentificadorGiro :
Numero o etiqueta clave que identifica el giro.  Buscar más adelante los giros admisibles.
RotarX :
Indica la rotacion en grados respecto eje X*, este es el mismo eje X luego de trasladar y aplicar rotación en otros puntos de control.  Las rotaciones se acumulan a partir de la posicion base.
RotarY :
Indica rotacion acumulada respecto eje Y*, este es el eje Y luego de trasladar y aplicar RotarX.
RotarZ :
Indica rotacion acumulada respecto eje Z*, este es el eje Z luego de trasladar y aplicar RotarX y RotarY.
[, on/off] :
Parámetro optativo, útil en diseño y animación.  Cuando se indique off, se desactiva el giro.
La siguiente es la lista de los identificadores de giro posible.
SRAV_EjeCentral
Ubicado en el centro del tronco.
SRAV_EjeCentralD01
Ubicado delante de SRAV_EjeCentral.
SRAV_EjeCentralD02
Ubicado delante de SRAV_EjeCentralD01.
SRAV_EjeCentralD03
Ubicado delante de SRAV_EjeCentralD02.
SRAV_EjeCentralD04
Ubicado delante de SRAV_EjeCentralD03.
SRAV_EjeCentralD05
Ubicado delante de SRAV_EjeCentralD04.
SRAV_EjeCentralD06
Ubicado delante de SRAV_EjeCentralD05.
SRAV_EjeCentralD07
Ubicado delante de SRAV_EjeCentralD06.
SRAV_EjeCentralD08
Ubicado delante de SRAV_EjeCentralD07.
SRAV_EjeCentralD09
Ubicado delante de SRAV_EjeCentralD08.
SRAV_EjeCentralD10
Ubicado delante de SRAV_EjeCentralD09.
SRAV_EjeCentralD11
Ubicado delante de SRAV_EjeCentralD10.
SRAV_EjeCentralD12
Ubicado delante de SRAV_EjeCentralD11.
SRAV_EjeCentralD13
Ubicado delante de SRAV_EjeCentralD12.
SRAV_EjeCentralD14
Ubicado delante de SRAV_EjeCentralD13.
SRAV_EjeCentralD15
Ubicado delante de SRAV_EjeCentralD14.
SRAV_EjeCentralD16
Ubicado delante de SRAV_EjeCentralD15.
SRAV_EjeCentralD17
Ubicado delante de SRAV_EjeCentralD16.
SRAV_EjeCentralD18
Ubicado delante de SRAV_EjeCentralD17.
SRAV_EjeCentralD19
Ubicado delante de SRAV_EjeCentralD18.
SRAV_EjeCentralD20
Ubicado delante de SRAV_EjeCentralD19.
SRAV_EjeCentralD21
Ubicado delante de SRAV_EjeCentralD20.
SRAV_EjeCentralD22
Ubicado delante de SRAV_EjeCentralD21.
SRAV_EjeCentralD23
Ubicado delante de SRAV_EjeCentralD22.
SRAV_EjeCentralD24
Ubicado delante de SRAV_EjeCentralD23.
SRAV_EjeCentralD25
Ubicado delante de SRAV_EjeCentralD24.
SRAV_EjeCentralD26
Ubicado delante de SRAV_EjeCentralD25.
SRAV_EjeCentralD27
Ubicado delante de SRAV_EjeCentralD26.
SRAV_EjeCentralP01
Ubicado detrás de SRAV_EjeCentral.
SRAV_EjeCentralP02
Ubicado detrás de SRAV_EjeCentralP01.
SRAV_EjeCentralP03
Ubicado detrás de SRAV_EjeCentralP02.
SRAV_EjeCentralP04
Ubicado detrás de SRAV_EjeCentralP03.
SRAV_EjeCentralP05
Ubicado detrás de SRAV_EjeCentralP04.
SRAV_EjeCentralP06
Ubicado detrás de SRAV_EjeCentralP05.
SRAV_EjeCentralP07
Ubicado detrás de SRAV_EjeCentralP06.
SRAV_EjeCentralP08
Ubicado detrás de SRAV_EjeCentralP07.
SRAV_EjeCentralP09
Ubicado detrás de SRAV_EjeCentralP08.
SRAV_EjeCentralP10
Ubicado detrás de SRAV_EjeCentralP09.
SRAV_EjeCentralP11
Ubicado detrás de SRAV_EjeCentralP10.
SRAV_EjeCentralP12
Ubicado detrás de SRAV_EjeCentralP11.
SRAV_EjeCentralP13
Ubicado detrás de SRAV_EjeCentralP12.
SRAV_EjeCentralP14
Ubicado detrás de SRAV_EjeCentralP13.
SRAV_EjeCentralP15
Ubicado detrás de SRAV_EjeCentralP14.
SRAV_EjeCentralP16
Ubicado detrás de SRAV_EjeCentralP15.
SRAV_EjeCentralP17
Ubicado detrás de SRAV_EjeCentralP16.
SRAV_EjeCentralP18
Ubicado detrás de SRAV_EjeCentralP17.
SRAV_EjeCentralP19
Ubicado detrás de SRAV_EjeCentralP18.
SRAV_EjeCentralP20
Ubicado detrás de SRAV_EjeCentralP19.
SRAV_EjeCentralP21
Ubicado detrás de SRAV_EjeCentralP20.
SRAV_EjeCentralP22
Ubicado detrás de SRAV_EjeCentralP21.
SRAV_EjeCentralP23
Ubicado detrás de SRAV_EjeCentralP22.
SRAV_EjeCentralP24
Ubicado detrás de SRAV_EjeCentralP23.
SRAV_EjeCentralP25
Ubicado detrás de SRAV_EjeCentralP24.
SRAV_EjeCentralP26
Ubicado detrás de SRAV_EjeCentralP25.
SRAV_EjeCentralP27
Ubicado detrás de SRAV_EjeCentralP26.

Un ejemplo sencillo para utilizar la matriz de giro, sería el siguiente:

    #include "stdinc.inc"
    #include "stdcam.inc"
    #include "SRAV.inc"
    
    #declare MyArreglo   = array [ 2 ][ 5 ]
        { { SRAV_EjeCentralP10 , 0, 10, 0, on },
          { SRAV_EjeCentralD10 , 0, 10, 0, on } } 
          
    object       { 
      SRAV_Serpiente(MyArreglo,0.0) 
      translate          <-1.375,0.625,-2.5>
    }

Se consigue un mayor control sobre las características con la siguiente macro detallada.

    #macro SRAV_SerpienteReptilAnimalVivo
              ( MyArreglo, AvanceLengua, LargoPrincipal, 
                RadioPrincipal, FactorT, LargoCabeza,
                FactorCabeza, CorreccionZOjo, FinoCola, 
                FactorGordo, TexturaPrincipal, TexturaCabeza,
                TexturaCornea, TexturaEsclerotida, TexturaIris, 
                TexturaBoca, TexturaLengua )
MyArreglo :
Arreglo para controlar los giros. 
AvanceLengua :
Fracción entre 0.0 (adentro) y 1.0 (afuera) para sacar la lengua. 
LargoPrincipal :
Referencia para el largo de la serpiente.  Default es 3000*L.
RadioPrincipal :
Referencia para el radio del animal.  Default es 60*L.
FactorT :
Controla el valor threshold del blob.  Default es 0.9.
LargoCabeza :
Referencia para el largo de la cabeza.  Default es 100*L.
FactorCabeza :
Para incrementa o reducir el grueso de la cabeza.  Default es 0.3.
CorreccionZOjo :
Corrige en Z la posicion del ojo.  Positivo hacia afuera.  Default es 15*L.
FinoCola :
Referencia como entero para el grado de finura de la cola.  Default es 8.
FactorGordo :
Referencia para engrosar al centro la serpiente.  Default es 0.05.
TexturaPrincipal :
Textura principal de la serpiente.  Default es SRAV_TexturaPrincipal.
TexturaCabeza :
Textura para aplicar a la cabeza.  Origen en cabeza.  Default es SRAV_TexturaCabeza.
TexturaCornea :
Textura para aplicar a la córnea.  Default es SRAV_TexturaCornea.
TexturaEsclerotida :
Textura para aplicar a la esclerótida.  Default es SRAV_TexturaEsclerotida.
TexturaIris :
Textura para aplicar al iris.  Default es SRAV_TexturaIris.
TexturaBoca :
Textura para aplicar a la boca.  Se aplica por diferencia, poco perceptible.  Default es SRAV_TexturaBoca.
TexturaLengua :
Textura para aplicar a la lengua.  Default es SRAV_TexturaLengua.

En el siguiente ejemplo se ilustra el uso de la macro detallada, para dibujar exactamente el mismo dibujo inicial.

    #include "stdinc.inc"
    #include "stdcam.inc"
    #include "SRAV.inc"
    
    #declare MyArreglo   = array [ 2 ][ 5 ]
        { { SRAV_EjeCentralP10 , 0, 10, 0, on },
          { SRAV_EjeCentralD10 , 0, 10, 0, on } } 
          
    object       { 
      SRAV_SerpienteReptilAnimalVivo(MyArreglo,0.0,
              3.0, 0.06, 0.9, 0.1, 0.3, 0.015, 8, 0.05,        
              SRAV_TexturaPrincipal, SRAV_TexturaCabeza,
              SRAV_TexturaCornea, SRAV_TexturaEsclerotida, 
              SRAV_TexturaIris,  SRAV_TexturaBoca, 
              SRAV_TexturaLengua ) 
      translate          <-1.375,0.625,-2.5>
    }

Características del objeto

Mis dibujos están en unidades L (Lisa).  1 L equivale a 0.055063 pulgadas definido como 0.001 para POVRAY.  La serpiente default sin ningún giro tiene las siguientes características:
    Punto Mínimo	     = <-1400,-45,-65>
    Punto Máximo             = <+1620,+60,+65>
El centro del tronco aproximadamente en el origen y la cabeza orientada hacia X+, gravedad Y-.

Se definen las siguientes texturas base, que no deberían modificarse.  Para su correcta modificación consultar la sección Modificadores.

SRAV_DefaultTexturaPrincipal
Textura principal de la serpiente.
SRAV_DefaultTexturaCabeza
Textura para aplicar a la cabeza.  Origen en cabeza.
SRAV_DefaultTexturaCornea
Textura para aplicar a la córnea. 
SRAV_DefaultTexturaEsclerotida
Textura para aplicar a la esclerótida.
SRAV_DefaultTexturaIris
Textura para aplicar al iris. 
SRAV_DefaultTexturaBoca
Textura para aplicar a la boca.  Se aplica por diferencia, poco perceptible.
SRAV_DefaultTexturaLengua
Textura para aplicar a la lengua.

Modificadores

La siguiente es la lista de los modificadores permitidos en la unidad (cuando se indica, son valores default).

    #declare SRAV_TexturaPrincipal	= texture { ... }
Textura principal de la serpiente.

    #declare SRAV_TexturaCabeza		= texture { ... }

Textura para aplicar a la cabeza.  Origen en cabeza.

    #declare SRAV_TexturaCornea		= texture { ... }
Textura para aplicar a la córnea. 

    #declare SRAV_TexturaEsclerotida	= texture { ... } 
Textura para aplicar a la esclerótida.

    #declare SRAV_TexturaIris		= texture { ... }
Textura para aplicar al iris. 

    #declare SRAV_TexturaBoca		= texture { ... }
Textura para aplicar a la boca.  Se aplica por diferencia, poco perceptible.

    #declare SRAV_TexturaLengua		= texture { ... } 
Textura para aplicar a la lengua.

    #declare SRAV_POV3_1				= off;
Si se activa con "on" produce simplificaciones que permiten su ejecución en la version POVRay 3.1.  En algunas versiones de POVRay se activa automáticamente.

A manera de ejemplo del uso de los modificadores:

    #include "stdinc.inc"
    #include "stdcam.inc"
    #include "SRAV.inc"                       
    #include "textures.inc"
    
    #declare MyArreglo   = array [ 2 ][ 5 ]
        { { SRAV_EjeCentralP10 , 0, 10, 0, on },
          { SRAV_EjeCentralD10 , 0, 10, 0, on } } 
    
    #declare SRAV_TexturaPrincipal      = PinkAlabaster
    #declare SRAV_TexturaCabeza         = Rust
    #declare SRAV_TexturaCornea         = texture { pigment { Clear  } }
    #declare SRAV_TexturaEsclerotida    = texture { pigment { Yellow } } 
    #declare SRAV_TexturaIris           = texture { pigment { Cyan   } }  
    #declare SRAV_TexturaLengua         = texture { pigment { White  } }
          
    object       { 
      SRAV_Serpiente(MyArreglo,1.0)
      rotate            100*y
      rotate            10*x
      translate          <-1.375,0.625,-2.5>
    }

Notas y Advertencias

La textura de boca se aplica por diferencia, y casi no se nota.

Al cambiar los parámetros de la serpiente, probablemente requiera ajustar el parámetro CorreccionZOjo.  Nosotros lo ajustamos por prueba y error.

Los giros se interpretan algo diferente en la parte frontal y en la parte delantera de la serpiente.


Sugerencias de modificación


Sobre LibreN3D

Algo hace falta En la actualidad dedico casi unas dos horas todos los días, para desarrollar el programa de animación LibreN3D con el compilador FreePascal para FreeDOS.  El objetivo era en un origen, realizar animaciones de "baja" calidad, con progreso lento y paulatino. Desconocía en ese entonces del programa POV-Ray.  Creo que con ayuda de dicho proyecto, podría lograr mucho mejores resultados desde un principio.  Confío que para el 2020 pueda lograr animaciones completas de aceptable calidad.   En la actualidad, intento agregarle características elásticas a los objetos.  He tenido numerosos retrasos, así que todavía no funciona.  Lo siento... (19/febrero/2014), pero me siento muy seguro de que pronto lo lograré.  De momento, no tiene interface con el usuario, pero se encuentra en desarrollo como intérprete de renglón al estilo DOS.

Me sería de muchísima ayuda, que el grupo POV-Ray siguiera desarrollando la versión para DOS.   Los siguientes son enlaces que podrían ser de utilidad para el interesado en los proyectos FreePascal y FreeDOS.   Lamentablemente en la actualidad son altamente inestables, debido probablemente a dificultades con la adaptación al modo de 64 bits.
Logo FreeDOS...
Descarga sistema operativo FreeDOS
Logo FreePascal...
Descarga compilador FreePascal