EXTENDIENDO BLENDER

Al contrario de muchos programas con los que puedes estar familiarizado, Blender no es monolítico y estático. Puedes extender sus funcionalidades incluso sin tener que modificar las fuentes y recompilarlas. Hay dos maneras de realizar dicha extensión: Scripts en Python y Plugins, siendo el primero de los dos el preferido y mayormente usado. Esta parte describira ambas técnicas.
Capítulos

  • Scripts en Python
  • Sistema de plugins de Blender

Scripts en Python

Blender tiene una característica muy poderosa que a menudo es pasada por alto. Esta característica es un intérprete de Python totalmente funcional. Esto le permite a cualquier usuario añadir funcionalidades a Blender escribiendo un simple script de Python. Python es un lenguaje de programación interpretado, interactivo, y orientado a objetos. Incorpora módulos, excepciones, tipeado dinamico, tipo de datos dinamicos de muy alto nivel y clases. Python combina un gran poder con una sintaxis muy sencilla. Esta expresamente diseñado para ser usado como una extensión para las aplicaciones que necesiten una interfaz programable, y esto es por lo que Blender lo utiliza. De las dos maneras que tiene de extender Blender, siendo la otra los plugins binarios, la tratada aquí los script de Python es la más poderosa, versátil, más sencilla de comprender y robusta. Realmente es preferible usar Python que escribir un plugin. Realmente los script de Python tenían unas funcionalidades limitadas en Blender 2.25, la última de las versiones que liberó NaN. Cuando Blender se hizo código abierto muchos de los desarrolladores que se movían alrededor de la Fundación lo eligieron para trabajar y, junto con el cambio de UI, el API de Python es probablemente la parte de Blender que ha tenido un desarrollo más grande. Una total reorganización de lo que existía fue llevada a cabo y muchos nuevos módulos fueron añadidos. Dicha evolución esta aún en proceso y una mejor integración esta por venir en las próximas versiones de Blender. Blender tiene una ventana texto junto con los otros tipo de ventana la cual es accesible vía el botón del menú Tipos de Ventana o a través de SHIFT-F11.Una ventana de texto recién abierta es gris y esta vacía, y tiene una barra de herramientas muy sencilla (Barra de herramientas de texto.). De izquierda a derecha están el botón estándar de selección de ventana y el menú ventana. Luego esta el botón de pantalla completa, seguido por un botón que muestra/oculta el número de líneas del texto y el botón Menú.


Barra de herramientas de texto.

El botón Menú () permite seleccionar que buffer de texto tiene que ser mostrado, y también le permite crear un nuevo buffer o cargar un fichero de texto. Si elige cargar un fichero en la ventana texto temporalmente se crea una ventana de selección de ficheros, con las funciones usuales. Una vez que el buffer de texto esta en la ventana texto, esta se convierte en un editor de texto muy simple. Escribir en el teclado provoca que aparezca texto en el buffer de texto. Como siempre con presionar LMB arrastrar y liberar LMB se selecciona el texto. Los siguientes comandos del teclado son aplicables:

  • ALT-C o CTRL-C - Copia el texto marcado al portapapeles;
  • ALT-X o CTRL-X - Corta el texto marcado al portapapeles;
  • ALT-V or CTRL-V - Pega el texto marcado desde portapapeles en la posición del cursor en la Ventana Texto;
  • ALT-S - Guarda el texto como un fichero de texto, una Ventana de Selección de Ficheros aparecera;
  • ALT-O - Carga un texto, una Ventana de Selección de Ficheros aparecera;
  • ALT-F - Emergera la herramienta buscar;
  • SHIFT-ALT-F o RMB - Emergera el Menú Fichero para la Ventana de Texto;
  • ALT-J - Emergera un panel donde puede especificar un número de línea para situar el cursor;
  • ALT-P - Ejecuta el texto como un script de Python;
  • ALT-U - Deshacer;
  • ALT-R - Rehacer;
  • CTRL-R - Reabrir (recargar) el buffer actual;
  • ALT-M - Convierte el contenido de la ventana de texto en texto 3D (max. 100 caracteres);
El portapapeles de Blender que corta/copia/pega esta separado del portapapeles de Windows así que no podra copiar desde o hacia Blender. Para acceder a su portapapeles de Windows utilice SHIFT-CTRL-C SHIFT-CTRL-V. Para eliminar un buffer de texto tan sólo presione el botón 'X'. próximo al nombre del buffer, tal y como hace para los materiales, etcétera. La más importante combinación de teclas es ALT-P la cual hace que el contenido del buffer sea pasado al intérprete de Python de Blender. La siguiente sección le mostrara un ejemplo de script de Python. Antes de que continúe tenga en cuenta que Blender viene con un intérprete de Python muy sencillo con unos pocos módulos totalmente específicos de Blender, que están descritos en la **REFERENCIA**.


Otros usos para la ventana de texto: La ventana de texto se utiliza también cuando quieres compartir tus ficheros .blend con la comunidad o con tus amigos. Puedes usarla para escribir un texto aclaratorio de los contenidos de tu fichero. Esto es mucho más interesante que tener dicho fichero en un archivo separado. Asegurate de mantenerlo visible mientras salves tu fichero!. Si compartes el archivo con la comunidad y quieres hacerlo bajo alguna licencia puedes escribir dicha licencia en una ventana texto. Para tener acceso a los módulos estándar de Python necesitarás tener instalado Python. Puedes descargarlo de Python Programming Language -- Official Website.


Configurando la variable del sistema PYTHONPATH

Asegurate de comprobar en blender.org - Home cual versión exacta de Python es con la que fue construida Blender para evitar posibles problemas de compatibilidad. Blender también debe conocer donde se ha realizado dicha instalación. Esto se hace definiendo una variable entorno PYTHONPATH.

Configurando PYTHONPATH en Win95,98,Me

Una vez que haya instalado Python en, digamos, C:\PYTHON22 debe editar el fichero C:\AUTOEXEC.BAT con su editor de textos favorito y añadir una linea:

Código:
SET PYTHONPATH=C:\PYTHON22;C:\PYTHON22\DLLS;C:\PYTHON22\LIB;C:\PYTHON22\LIB\LIB-TK
y reiniciar el sistema.


Configurando PYTHONPATH en WinNT,2000,XP

Una vez que haya instalado Python en, digamos, C:\PYTHON22. Vaya al icono "Mi PC" en el escritorio, RMB y seleccione Properties. Seleccione la pestaña Advanced y presione el botón Environment Variables. Debajo de la caja de Variables del Sistema, (la segunda caja), pinche en New. Si no eres administrador posiblemente no seas capaz de hacer esto. En este caso pinche en New en la caja superior. Ahora, en la caja "Variable Name" (Nombre de variable), escriba PYTHONPATH y en la caja "Variable Value" (Valor de la variable), escriba:

Código:
C:\PYTHON22;C:\PYTHON22\DLLS;C:\PYTHON22\LIB;C:\PYTHON22\LIB\LIB-TK
Pulse OK repetidamente para salir de todos los diálogos. Dependiendo del sistema operativo quizás tengas que reiniciar.

Configurando PYTHONPATH en Linux y otros UNIXes

Normalmente tendrás Python ya instalado. Si no fuese así, hazlo. Ahora solo tendrás que descubrir donde esta instalado. Esto es sencillo, solo arranque una shell interactiva de Python simplemente abriendo una shell y escribiendo python en ella. Escriba los siguientes comandos:


Código:
>>> import sys
>>> print sys.path
y anote lo que se muestre por pantalla que debería ser algo como


Código:
['', '/usr/local/lib/python2.2', '/usr/local/lib/python2.2 /plat-linux2', '/usr/local/lib/python2.0/lib-tk', '/usr/local/lib/python2.0/lib-dynload', '/usr/local/lib/python2.0/site-packages']
Añada esto a su fichero favorito rc (fichero de configuración) como una variable de entorno. Por ejemplo, añada en su .bashrc la siguiente linea

Código:
export PYTHONPATH=/usr/local/lib/python2.2:/usr/local/lib/python2.2/plat-linux2:/usr/local/lib/python2.2/lib-tk:/usr/local/lib/python2.2/lib-dynload:/usr/local/lib/python2.0/site-packages
todo en una única línea. Abra una nueva shell, o salga e introduzca de nuevo el login.

Un ejemplo funcional de Python

Ahora que ha visto que Blender es extensible vía script de Python y que tiene los elementos básicos para el manejo de scripts y sabe como lanzarlos, antes de estrujar su cerebro con la API de Python echemos un vistazo a un pequeño ejemplo. Realizaremos un pequeño script para producir polígonos. Este script duplica lo que hace SPACEAdd>>Mesh>>Circle, pero creara polígonos rellenos, no sólo con el perímetro exterior. Para hacer el script aún más completo este exhibira una interfaz gráfica de usuario (GUI) escrita completamente a través de la API de Blender.

Cabeceras, importación de los módulos y variables globales

Las primeras 32 líneas de código son mostradas abajo.
Cabecera del script

Código:
001 ######################################################
002 #
003 # Script demostración para la Guia de Blender 2.3
004 #
005 ###################################################S68
006 # Este script genera polígonos. Es bastante inútil
007 # ya que puedes hacer lo mismo con ADD->Mesh->Circle
008 # pero es un buen ejemplo, y además los 
009 # polígonos están 'rellenos'.
010 ######################################################
011 
012 ######################################################
013 # Importación de los módulos
014 ######################################################
015
016 import Blender
017 from Blender import NMesh
018 from Blender.BGL import *
019 from Blender.Draw import *
020
021 import math
022 from math import *
023
024 # Parámetros del Polígono
025 T_NumberOfSides = Create(3)
026 T_Radius = Create(1.0)
027
028 # Events
029 EVENT_NOEVENT = 1
030 EVENT_DRAW = 2
031 EVENT_EXIT = 3
032
Después de necesarios comentarios que indican lo que hace el script se encuentra la importación de los módulos de Python (lineas 016-022). Blender es el módulo principal de la API de Python de Blender. NMesh es el módulo que proporciona acceso a las mallas de Blender, mientras que BGL y Draw dan acceso a las funciones y constantes de OpenGL y a la interfaz de ventanas de Blender, respectivamente. El módulo math es el módulo matemático de Python, pero dado que ambos módulos 'math' y 'os' están incluidos dentro de Blender no necesita una completa instalación de Python para usarlos!. Los polígonos se definen a través del número de lados y de su radio. Estos parámetros tienen valores que deben ser definidos por el usuario a través del GUI, líneas (025-026), con lo que se deben crear dos 'botones genéricos', con sus valores por defecto. Finalmente, los objetos GUI trabajaran con eventos y también los generaran. Los identificadores de los eventos son enteros que serán definidos por el programador. Es una buena practica utilizar nombres fáciles de recordar para los eventos, como se hace en la líneas (029-031).

Dibujando el GUI

El código fuente que se encarga del dibujado del GUI esta en la función draw (dibujo) (Dibujando el GUI).
Dibujando el GUI


Código:
033 ######################################################
034 # Dibujando el GUI
035 ######################################################
036 def draw():
037 	global T_NumberOfSides
038 	global T_Radius
039 	global EVENT_NOEVENT,EVENT_DRAW,EVENT_EXIT
040
041 	########## Titles
042 	glClear(GL_COLOR_BUFFER_BIT)
043 	glRasterPos2d(8, 103)
044 	Text("Demo Polygon Script")
045
046 	######### Parameters GUI Buttons
047 	glRasterPos2d(8, 83)
048 	Text("Parameters:")
049 	T_NumberOfSides = Number("No. of sides: ", EVENT_NOEVENT, 10, 55, 210, 18,
050 T_NumberOfSides.val, 3, 20, "Number of sides of out polygon");
051 	T_Radius = Slider("Radius: ", EVENT_NOEVENT, 10, 35, 210, 18,
052 T_Radius.val, 0.001, 20.0, 1, "Radius of the polygon");
053
054 	######### Draw and Exit Buttons
055 	Button("Draw",EVENT_DRAW, 10, 10, 80, 18)
056 	Button("Exit",EVENT_EXIT, 140, 10, 80, 18)
057

Las líneas (037-039) proporcionan acceso a los datos globales. El verdadero meollo del asunto comienza a partir de las líneas (042-044). La ventana de OpenGL es inicializada, y su actual posición configurada a x=8, y=103. El origen de esta referencia es la esquina inferior izquierda de la ventana de scripts. Entonces el título Demo Polygon Script es mostrado. Una cadena de caracteres es escrita en las líneas (047-04, entonces se crean los botones para introducir los parámetros. El primero (lineas 049-050) es un botón numérico, exactamente como esos que hay en la ventana de botones de Blender. Para comprender todos los parámetros por favor diríjase a la referencia de la API. Basicamente esta la etiqueta del botón, el evento generado por el botón, su localización (x,y) y sus dimensiones (anchura, altura), su valor, que es un dato perteneciente al objeto mismo, los valores máximos y mínimos permitibles y un texto que aparecerá como ayuda mientras sitúa el cursor sobre el botón, como una etiqueta de ayuda. Las líneas (051-052) definen un botón numérico con un deslizador, con una sintaxis muy similar. Las líneas (055-056) finalmente crean el botón Draw (Dibujar)el cual creara los polígonos y un botón Exit (Salir).


Manejando eventos

El GUI no se ha dibujado, y no trabajara, hasta que se escriba un manejador de eventos apropiado y se registre (Manejando eventos).
Manejando eventos


Código:
058 def event(evt, val):	
059 	if (evt == QKEY and not val):
060 		Exit()
061
062 def bevent(evt):
063 	global T_NumberOfSides
064 	global T_Radius
065 	global EVENT_NOEVENT,EVENT_DRAW,EVENT_EXIT
066
067 	######### Manages GUI events
068 	if (evt == EVENT_EXIT):
069 		Exit()
070 	elif (evt== EVENT_DRAW):
071 		Polygon(T_NumberOfSides.val, T_Radius.val)
072 		Blender.Redraw()
073
074 Register(draw, event, bevent)
075
Las líneas (058-060) definen el manejador de eventos del teclado, en este caso respondiendo a la que con una sencilla llamada a Exit(). Hay más interesantes líneas en (062-072) donde se manejan los eventos del GUI. Cada vez que un botón del GUI es usado esta función es llamada, con el número de evento definido en el los parámetros del botón. El núcleo de esta función es una estructura de "selección" que ejecuta diferentes códigos dependiendo del número de evento. Como última llamada, se invoca a la función Register. Esto efectivamente dibuja el GUI y comienza el bucle que captura los eventos.
Manejando Mallas

Finalmente, Cabecera del script muestra la función principal, la que crea el polígono. Es una simple edición de la malla, pero muestra muchos puntos importantes de la estructura interna de datos de Blender.
Cabecera del script

Código:
076 ######################################################
077 # Cuerpo principal
078 ######################################################
079 def Polygon(NumberOfSides,Radius):
080
081	######### Creates a new mesh
082	poly = NMesh.GetRaw()
083
084	######### Populates it of vértices
085	for i in range(0,NumberOfSides):
086	 phi = 3.141592653589 * 2 * i / NumberOfSides
087	 x = Radius * cos(phi)
088	 y = Radius * sin(phi)
089	 z = 0
090
091	 v = NMesh.Vert(x,y,z)
092	 poly.verts.append(v)
093
094	######### Adds a new vertex to the center
095	v = NMesh.Vert(0.,0.,0.)
096	poly.verts.append(v)
097
098	######### Connects the vértices to form faces
099	for i in range(0,NumberOfSides):
100		f = NMesh.Face()
101		f.v.append(poly.verts[i])
102		f.v.append(poly.verts[(i+1)%NumberOfSides])
103		f.v.append(poly.verts[NumberOfSides])
104		poly.faces.append(f)
105
106	######### Creates a new Object with the new Mesh
107	polyObj = NMesh.PutRaw(poly)
108
109	Blender.Redraw()
La primera línea importante aquí es la número (082). Aquí hay un nuevo objeto malla, donde se crea el poly polígono. El objeto malla esta constituido de una lista de vértices y de una lista de caras, además de otras interesantes cosas. Para nuestros propósitos los vértices y la lista de caras será lo que necesitaremos. Por supuesto la malla recientemente creada ésta vacía. El primer bucle (lines 085-092) calculara la localización x,y,z de los vértices NumberOfSides necesarios para definir el polígono. Para un plano su coordenada 'z' será cero para todos los vértices. La línea (091) llama al método Vert de NMesh para crear un nuevo objeto vértice de coordenadas (x,y,z). Tal objeto es entonces añadido (linea 096) en la lista de verts vértices de la malla poly polígono. Finalmente en las líneas (095-096) un último vértice es añadido al centro. Las líneas (099-104) conectan los vértices para crear las caras. No será necesario crear todos los vértices primero y luego las caras. Podrás crear una nueva cara tan pronto como todos los vértices estén disponibles. La línea (100) crea una nueva cara. Un objeto cara tiene su propia lista de vértices v (hasta 4) definidos. Las líneas (101-103) añaden 3 vértices a la lista f.v originalmente vacía. Los vértices son dos vértices adyacentes del polígono y el vértice central. Estos vértices deben de ser tomados de la lista de verts vértices de la malla. Finalmente la línea (104) añade la cara recién creada a la lista de faces caras de nuestra malla poly polígono.
Conclusiones

Si crea su fichero polygon.py conteniendo el código anteriormente descrito y lo carga dentro de una ventana de texto de Blender, como ha aprendido en la sección anterior y presiona ALT-P en dicha ventana para lanzarlo vera como la ventana desaparece y se vuelve gris. En la esquina inferior izquierda el GUI se dibujara (El GUI de nuestro ejemplo.).


El GUI de nuestro ejemplo.

Seleccionando, por ejemplo, 5 vértices y un radio de 0.5, y presionando el botón Draw aparecerá un pentagono en el plano xy de la ventana 3D (El resultado de nuestro script de ejemplo.).


El resultado de nuestro script de ejemplo.

Referencia de Python

La documentación de referencia del lenguaje de programación Python para Blender es un libro en si mismo. Por razones de espacio no se incluye en este documento. Aquí esta


Scripts de Python

Hay más de 100 scripts para Blender disponibles en Internet. Como los plugins, los scripts son muy dinamicos, cambiando su interfaz, sus funcionalidades y su localización en Internet muy rápidamente, así que para una lista actualizada de ellos por favor dirijase a uno de estos dos sitios, blender.org - Home o Blender Artists Forums - Powered by vBulletin.

Sistema de plugins de Blender

Esta sección muestra una referencia detallada de como escribir plugins de Secuencia y de Textura para Blender.


Escribiendo un plugin de Textura

En esta sección escribiremos un plugin de textura básico y después enseñaremos a usarlo. Los elementos básicos detrás de un plugin de textura consisten en que tu estas dando algunos valores de entrada, tales como posición, etc y alguna información más. Entonces dependiendo del tipo de plugin de textura se te devolvera información sobre la intensidad, el color y/o las normales. Tanto los archivos necesarios para desarrollar los plugins como unos pocos plugins se pueden encontrar en el directorio blender/plugins. Alternativamente puede obtener más plugins de http://www.cs.umn.edu/~mein/blender/plugins. Los plugins son utilizados (cargados/llamados) en Blender a través de dlopen(). Para aquellos que no están familiarizados con el sistema dlopen diremos que este permite a un programa (Blender) usar un objeto compilado como si éste fuese parte del programa mismo, similar a cuando se enlazan librerías dinamicamente, exceptuando que el objeto a cargar se determina cuando se esta ejecutando el programa. La ventaja de usar el sistema dlopen para los plugins consiste en que es muy rápido acceder a una función, y además no hay sobrecarga en la interfaz del plugin, lo cual es crítico cuando (como en el caso de los plugins de textura) el plugin se puede llamar varios millones de veces en un único render. La desventaja de este sistema es que el plugin funciona como si realmente fuese parte de Blender, con lo que si el plugin se muere, Blender muere. Los ficheros de cabecera que se encuentran en el subdirectorio plugin/include/ de la instalación de Blender están documentados mostrando las funcionalidades que se proporcionan a los plugins. Dichas funcionalidades incluyen las funciones de las librería Imbuf para cargar y trabajar con imágenes y buffers de imagen, y funciones de ruido y turbulencia para un texturizado consistente.

Especificación

  • #include <plugin.h>
Todos los plugins de Blender deben incluir este fichero cabecera, que contiene todas las estructuras y definiciones necesarias para trabajar correctamente con Blender.
  • char name[]="Tiles";
Un string (cadena de caracteres) conteniendo el nombre del plugin, este valor se usara para indicar el título de la textura en la ventana de botones de textura
  • define NR_TYPES 2 char stnames[NR_TYPES][16]= {"Square", "Deformed"};
A los Plugins se les permite tener subtipos separados para variaciones minimas en algoritmos - por ejemplo la textura "clouds (nubes)" que esta por defecto en Blender tiene los subtipos "Default" y "Color". NR_STYPES debería ser definido con el número de subtipos que el plugin requiera, y además a cada subtipo se le tiene que dar un nombre. Cada plugin debe tener al menos 1 subtipo y el nombre de ese subtipo.
  • VarStruct varstr[]= {...};

"varstr" contiene toda la información que Blender necesita para mostrar los botones del plugin. Los botones para los plugin pueden ser de tipo numerico para introducir datos, o de tipo texto para introducir comentarios u otra información. Se pueden utilizar como máximo 32 variables en los plugins. Cada estructura VarStruct consta de un tipo, un nombre, un rango de información y una nota emergente sobre la herramienta. El tipo define el tipo de dato para cada botón, y la manera en la que se muestra dicho botón. Para botones numéricos este valor debería ser una combinación (ORed) de INT o FLO para el formato del número y NUM, NUMSLI o TOG para el tipo de botón. Los botones de texto son de tipo LABEL. El nombre es lo que se mostrara en el botón y esta limitado a 15 caracteres. El rango de información consiste en 3 números reales que definen los valores máximo, mínimo y "por defecto" para el botón. Para los botones TOG el mínimo es configurado cuando el botón se haya presionado y el máximo cuando esta sin presionar. La nota emergente (tool tip) es una cadena de caracteres que se mostrara cuando el puntero esté encima del botón (si el usuario tiene los tool tips activos). Tiene un límite de 80 caracteres y se tiene que poner a NULL (") si no se utiliza.
  • typedef struct Cast {...};
La estructura Cast se usa en la llamada a la función doit, y simplifica el acceso de cada plugin a los valores de los datos. La estructura Cast debería contener, en este orden, un entero o número real por cada botón definido en varstr, incluidos los botones de texto. Típicamente deberían tener el mismo nombre que el botón para permitir una búsqueda o una referencia sencilla.
  • float result[8];
El vector result se usa para enviar y recibir información al plugin. Los valores de result están definidos de esta manera: Result Índice Significado Rango result[0] Valor de la intensidad 0.0 to 1.0 result[1] Valor del color rojo 0.0 to 1.0 result[2] Valor del color verde 0.0 to 1.0 result[3] Valor del color azul 0.0 to 1.0 result[4] Valor del color transparente (alpha) 0.0 to 1.0 result[5] Valor del desplazamiento normal en X result[6] Valor del desplazamiento normal en Y result[7] Valor del desplazamiento normal en Z El plugin siempre devuelve el valor de la intensidad. Devolver el color (RGB) o la normal es opcional, y se debería indicar con el "return" de la función doit(), siendo "1" para (RGB) y "2" para (Normal). Antes de que se llame al plugin, Blender asigna el resultado de renderizar normalmente en result[5], result[6] y result[7].
  • float cfra
El valor cfra actualizado por Blender a su valor actual antes de que todos los renders se hagan. Este valor es el número de frame +/- .5 dependiendo de las configuraciones del campo.
  • plugin_tex_doit prototype
La función plugin_tex_doit debería ser prototipada para que pueda ser usada por la función getinfo. No necesita cambiar esta línea.
  • plugin_tex_getversión
Esta función debería estar en cada plugin para que pueda ser cargado correctamente. No debería cambiar esta función.
  • plugin_but_changed
Esta función se usa para pasar información sobre que botones cambia el usuario en la interface. La mayoría de los plugins no necesitan esta función, solo cuando el interface permita al usuario modificar algunas variables que furze al plugin a recalcularse (una tabla hash aleatoria por ejemplo).
  • plugin_init
Si fuese necesario los plugins pueden utilizar esta función para inicializar datos internos. NOTA: Esta función de iniciacion se puede llamar varias veces si el mismo plugin de textura se copia. En esta función, no inicialice datos globales especificos a una única instancia de un plugin.
  • plugin_getinfo
Esta función se usa para comúnicar información a Blender. Nunca deberías cambiarla.
  • plugin_tex_doit
La función doit es la responsable de devolver información a Blender sobre pixeles requeridos. Los Argumentos
  • int stype
Este es el número de subtipos seleccionados, mira las entradas NR_TYPES y char stypes anteriores.
  • Cast *cast
La estructura Cast que contiene los datos del plugin, mira la entrada Cast anterior.
  • float *texvec
Esto es un puntero a 3 floats, los cuales son las coordenadas para las cuales un valor de la textura debe retornarse.
  • float *dxt float *dyt
Si los punteros son no-NULL apuntaran a 2 vectores (2 arrays de 3 floats) que definen el tamaño del valor textura requerida en el espacio pixel Apuntan solo a no-NULL cuando el OSA esté activado, y se usan para calcular adecuadamente el antialiasing. La función doit debería rellenar el array result y devolver 0, 1, 2 o 3 dependiendo de que valores hayan rellenado el array. La función doit debería siempre rellenarse con el valor intensidad. Si la función asigna el valor "color" debería devolver 1, si asigna el valor "normal" debería devolver 2 y si asigna todo devería devolver 3.

Interacción Texturas/Materiales

Blender es algo diferente de la mayoría de paquetes 3D en lo que se refiere a la separación lógica entre materiales y textura En Blender las texturas son objetos que devuelven ciertos valores, son generadores de señales de hecho. Los materiales controlan el mapeado de texturas en los objetos, lo que esta afectado, en que cantidad, en que manera, etc. Plugins adecuadamente diseñados deberían incluir únicamente variables que afecten a la señal devuelta no al mapeado de ella. Es mejor incluir botones para controlar el escalado, el rango, los ejes, etc únicamente cuando hagan a la textura más fácil de usar (en caso del botón tamaño en el plugin Tiles) o aceleran el calculo (los subtipos Intensity/Color/Bump en el plugin Clouds2). De otra manera los botones del material hacen a esos botones redundantes, y la interfaz incrementa innecesariamente su complejidad.



Un plugin de textura genérico:

Código:
#include "plugin.h"

/* Nombre de la textura */
char name[24]= ";

#define NR_TYPES 3
char stnames[NR_TYPES][16]= {"Intens","Color", "Bump"};
/* Estructura para los botones,
 * butcode name default min max 0
 */

VarStruct varstr[]= {
 {NUM|FLO, "Const 1", 1.7, -1.0, 1.0, "},
};


typedef struct Cast {
 float a;
} Cast;

float result[8];
float cfra;
int plugin_tex_doit(int, Cast*, float*, float*, float*);

/* Funciones fijas */
int plugin_tex_getversión(void) {
 return B_PLUGIN_VERSION;
}

void plugin_but_changed(int but) { }

void plugin_init(void) { }

void plugin_getinfo(PluginInfo *info) {
 info->name= name;
 info->stypes= NR_TYPES;
 info->nvars= sizeof(varstr)/sizeof(VarStruct);

 info->snames= stnames[0];
 info->result= result;
 info->cfra= &cfra;
 info->varstr= varstr;

 info->init= plugin_init;
 info->tex_doit= (TeXDoit) plugin_tex_doit;
 info->callback= plugin_but_changed;
}

int plugin_tex_doit(int stype, Cast *cast, float *texvec, float *dxt,
 float *dyt) {

 if (stype == 1) {
 return 1;
 } if (stype == 2) {
 return 2;
 }
 return 0;
}
Nuestras modificaciones:

El primer paso es tener un plan. Para qué sirve este plugin y como los usuarios interactuaran con él. Para este ejemplo crearemos una textura sencilla que crea un simple patrón de ladrillos. Ahora copiaremos nuestro plugin genérico al archivo cube.c y rellenaremos los espacios vacíos. Es siempre una buena idea añadir algunos comentarios. Lo primero de todo es decir a los usuarios qué hace el plugin, de donde pueden obtener una copia, con quién deberían contactar para mejorarlo o para informar de fallos y cual es la licencia del código. Cuando uses comentarios asegurate de usar /* */. Los plugins están en C y algunos compiladores de C no aceptan los comentarios con el estilo de C++ (//).


Código:
/* 
Descripción: Este plugin es un ejemplo de plugin de textura que crea
un simple patrón de ladrillos.

Toma dos valores, el tamaño brik y el tamaño mortar.
El tamaño brik es el tamaño de cada ladrillo.
El tamaño mortar es el tamaño que hay entre los ladrillos (cemento).

Autor: Kent Mein (mein@cs.umn.edu)
Sitio web: <nowiki>http://www.cs.umn.edu/~mein/bender/plugins
Licencia: Dominio Público
Última modificación: Tue Oct 21 0:57:13 CDT 2003
*/
</nowiki>

Lo siguiente que necesitamos será rellenar el nombre, realmente debería ser el mismo que tu fichero .c, preferiblemente descriptivo, con menos de 23 caracteres, sin espacios y todas las letras en minúsculas.

Código:
char name[24]= "cube.c";
Vamos a mantener este plugin simple, solo tiene un tipo que esta relacionado con la intensidad. Así que necesitamos lo siguiente:

Código:
#define NR_TYPES 1
char stnames[NR_TYPES][16]= {"Default"};
Para nuestro interfaz vamos a permitir a la gente cambiar el tamaño del ladrillo, el espaciado entre ellos y los valores de intensidad devueltos por el ladrillo y el espaciado entre ladrillos. Para ello necesitamos modificar varstr y Cast. Cast debería tener una variable por cada entrada que haya en varstr.

Código:
/* Estructura para los botones,
 * butcode name default min max Tool tip
 */
VarStruct varstr[]= {
 {NUM|FLO, "Brick", .8, 0.1, 1.0, "Size of Cell"},
 {NUM|FLO, "Mortar", .1, 0.0, 0.4, "Size of boarder in cell"},
 {NUM|FLO, "Brik Int", 1, 0.0, 1.0, "Color of Brick"},
 {NUM|FLO, "Mortar Int", 0, 0.0, 1.0, "Color of Mortar"},
};

typedef struct Cast {
 float brick,mortar, bricki, mortari;
} Cast;
Ahora rellenaremos la función plugin_tex_doit. Basicamente queremos romper nuestra textura en "bloques" que estarán formados de un ladrillo y del espaciado a lo largo de las aristas del ladrillo (cemento) y entonces determinar si estamos en el ladrillo o estamos en el cemento. El código siguiente hace esto.

Código:
int plugin_tex_doit(int stype, Cast *cast, float *texvec, float *dxt,
 float *dyt) {
 int c[3];
 float pos[3], cube;

 /* configura el tamaño de nuestro bloque */
 cube = cast->brik + cast->mortar;

 /* necesitamos determinar donde estamos dentro del ladrillo actual. */
 c[0] = (int)(texvec[0] / cube);
 c[1] = (int)(texvec[1] / cube);
 c[2] = (int)(texvec[2] / cube);

 pos[0] = ABS(texvec[0] - (c[0] * cube));
 pos[1] = ABS(texvec[1] - (c[1] * cube));
 pos[2] = ABS(texvec[2] - (c[2] * cube));

 /* Descubrir si estamos en una posición de cemento o no. */
 if ((pos[0] <= cast->mortar) || (pos[1] <= cast->mortar) ||
 (pos[2] <= cast->mortar)) {
 result[0] = cast->mortari;
 } else {
 result[0] = cast->bricki;
 }
 return 0;
}
Una cosa que destacar, la función ABS esta definida en una cabecera que esta en plugins/include. En ese lugar hay otras funciones de uso común por lo que sería aconsejable que echará un vistazo allí.

Compilando:

bmake es una utilidad simple (shell script) para ayudar a la compilación y desarrollo de plugins, y puede encontrarse en el subdirectorio plugins del directorio de instalación de Blender. Se invoca mediante: bmake (nombre_plugin.c) e intentara enlazar las librerías adecuadas y compilar adecuadamente para su sistema el archivo C especificado. Si usted esta intentando desarrollar plugins en una máquina Windows, bmake puede no funcionar en este caso; debería usar lcc. Puede usar lo siguiente para compilar un plugin con lcc, asumiendo que usted tiene sus plugins en c:\blender\plugins: Aquí tiene un ejemplo de cómo se compilaría el plugin de textura sinus.c. Abra una ventana DOS y haga lo siguiente: (Nota: Asegúrese de que el directorio lcc\bin esta en su path)

Código:
cd c:\blender\plugins\texture\sinus
lcc -Ic:\blender\plugins\include sinus.c
lcclnque -DLL sinus.obj c:\blender\plugins\include\tex.def
implib sinus.dll

Escribiendo un plugin de Secuencia

En esta sección escribiremos un plugin de secuencia básico y luego seguiremos los pasos para usar un plugin de secuencia. Las bases de un plugin de secuencia son: se reciben unas entradas (1-3 buffers de imagen de entrada, así como alguna otra información), y se produce como resultado un buffer de imagen de salida. Todos los archivos necesarios para el desarrollo de plugins así como unos pocos plugins de ejemplo pueden encontrarse en el directorio blender/plugins. Puede conseguir adicionalmente un puñado de plugins en http://www.cs.umn.edu/~mein/blender/plugins.

Especificación:

  • #include <plugin.h>
Todos los plugins de Blender deben incluir este fichero cabecera, que contiene todas las estructuras y definiciones necesarias para trabajar correctamente con Blender.
  • char name[]="Blur";
Un string (cadena de caracteres) conteniendo el nombre del plugin, este valor se usara para indicar el título de la textura en la ventana de botones de textura.
  • VarStruct varstr[]= {...};
"varstr" contiene toda la información que Blender necesita para mostrar los botones del plugin. Los botones para los plugin pueden ser de tipo numerico para introducir datos, o de tipo texto para introducir comentarios u otra información. Se pueden utilizar como máximo 32 variables en los plugins. Cada estructura VarStruct consta de un tipo, un nombre, un rango de información y una nota emergente sobre la herramienta. El tipo define el tipo de dato para cada botón, y la manera en la que se muestra dicho botón. Para botones numericos este valor debería ser una combinación (ORed) de INT o FLO para el formato del número y NUM, NUMSLI o TOG para el tipo de botón. Los botones de texto son de tipo LABEL. El nombre es lo que se mostrara en el botón y esta limitado a 15 caracteres. El rango de información consiste en 3 números reales que definen los valores máximo, minimo y "por defecto" para el botón. Para los botones TOG el minimo es configurado cuando el botón se haya presionado y el máximo cuando esta sin presionar. La nota emergente (tool tip) es una cadena de caracteres que se mostrara cuando el puntero esté encima del botón (si el usuario tiene los tool tips activos). Tiene un límite de 80 caracteres y se tiene que poner a NULL (") si no se utiliza.
  • typedef struct Cast {...};
La estructura Cast se usa en la llamada a la función doit, y simplifica el acceso de cada plugin a los valores de los datos. La estructura Cast debería contener, en este orden, un entero o número real por cada botón definido en varstr, incluidos los botones de texto. Tipicamente deberían tener el mismo nombre que el botón para permitir una búsqueda o una referencia sencilla.
  • float cfra
El valor cfra actualizado por Blender a su valor actual antes de que todos los renders se hagan. Este valor es el número de frame +/- .5 dependiendo de las configuraciones del campo.
  • plugin_seq_doit prototype
La función plugin_seq_doit debería ser prototipada para que pueda ser usada por la función getinfo. No necesita cambiar esta línea.
  • plugin_seq_getversión
Esta función debería estar en cada plugin para que pueda ser cargado correctamente. No debería cambiar esta función.
  • plugin_but_changed
Esta función se usa para pasar información sobre que botones cambia el usuario en la interface. La mayoría de los plugins no necesitan esta función, solo cuando el interface permita al usuario modificar algunas variables que furze al plugin a recalcularse (una tabla hash aleatoria por ejemplo).
  • plugin_init
Si fuese necesario los plugins pueden utilizar esta función para inicializar datos internos. NOTA: Esta función de iniciacion se puede llamar varias veces si el mismo plugin de textura se copia. En esta función, no inicialice datos globales especificos a una única instancia de un plugin.
  • plugin_getinfo
Esta función se usa para comúnicar información a Blender. Nunca deberías cambiarla.
  • plugin_seq_doit
La función de secuencia doit es responsable de aplicar el efecto del plugin y de copiar los datos finales en el buffer de salida. Los argumentos
  • Cast *cast
La estructura Cast, que contiene los datos del plugin; véase la entrada Cast más arriba.
  • float facf0
El valor de la curva IPO del plugin para el offset del primer campo. Si el usuario no ha hecho una curva IPO, su rango va entre 0 y 1 para la duración del plugin.
  • float facf1
El valor de la curva IPO del plugin para el offset del segundo campo. Si el usuario no ha hecho una curva IPO, su rango va entre 0 y 1 para la duración del plugin.
  • int x int y
La anchura y altura de los buffers de imagen, respectivamente.
  • int x int y
Un apuntador al primer buffer de imagen al que el plugin esta vinculado. Sera siempre un buffer de imagen valido.
  • Imbuf *ibuf2
Un apuntador al segundo buffer de imagen al que el plugin esta vinculado. Los plugins que usan este buffer deberían comprobar si es un buffer NULL, pues el usuario puede no haber vinculado el plugin a dos buffers.
  • Imbuf *out
El buffer de imagen de la salida del plugin.
  • Imbuf *use
Un apuntador al tercer buffer de imagen al que el plugin esta vinculado. Los plugins que usan este buffer deberían comprobar si es un buffer NULL, pues el usuario puede no haber vinculado el plugin a tres buffers. Estructura de imagen ImBuf La estructura ImBuf contiene siempre 32 bits de datos de píxel ABGR. Las estructuras ImBuf son siempre iguales en tamaño, indicado por los valores de x e y.
Interacción con el usuario Blender no tiene ninguna manera de saber cuantas entradas espera el plugin, por lo que le es posible a un usuario adjuntar sólo una entrada a un plugin que espera dos. Por esta razón es importante comprobar siempre los buffers que usa el plugin para asegurarnos de que son todos validos. Los plugins de secuencia deberían incluir también una etiqueta de texto describiendo el número de entradas requeridas en la interfaz de botones.

Plugin de Secuencia Genérico:

Código:
#include "plugin.h"
char name[24]= ";

/* estructura para los botones,
 * butcode name default min max 0
 */

VarStruct varstr[]= {
 { LABEL, "In: X strips", 0.0, 0.0, 0.0, "},
};


/* La estructura cast es para entrada en la función doit principal
 Varstr y Cast deben tener las mismas variables en el mismo orden */

typedef struct Cast {
 int dummy; /* debido al botón 'etiqueta' */
} Cast;

/* cfra: el fotograma actual */

float cfra;

void plugin_seq_doit(Cast *, float, float, int, int,
 ImBuf *, ImBuf *, ImBuf *, ImBuf *);

int plugin_seq_getversión(void) {
 return B_PLUGIN_VERSION;
}

void plugin_but_changed(int but) {
}

void plugin_init() {
}

void plugin_getinfo(PluginInfo *info) {
 info->name= name;
 info->nvars= sizeof(varstr)/sizeof(VarStruct);
 info->cfra= &cfra;

 info->varstr= varstr;

 info->init= plugin_init;
 info->seq_doit= (SeqDoit) plugin_seq_doit;
 info->callback= plugin_but_changed;
}

void plugin_seq_doit(Cast *cast, float facf0, float facf1, int xo, int yo,
 ImBuf *ibuf1, ImBuf *ibuf2, ImBuf *outbuf, ImBuf *use) {
 char *in1= (char *)ibuf1->rect;
 char *out=(char *)outbuf->rect;

}
Nuestras modificaciones:

El primer paso es diseñar un plan de juego. Qué hará este plugin, cómo interactuaran con él los usuarios. Para este ejemplo crearemos un filtro simple que tendrá un botón de deslizamiento para una intensidad de 0-255. Si alguno de los componentes R, G o B de un píxel en la imagen fuente es menos de la intensidad seleccionada, devolvera negro y alfa; de lo contrario devolvera lo que haya en la imagen. Ahora copiaremos nuestro plugin genérico a simpfilt.c y rellenaremos los vacíos. Siempre es una buena idea añadir algunos comentarios. Primero, explicar a los usuarios lo que hace el plugin, dónde pueden obtener una copia, a quién deberían contactar para fallos/mejoras, y cualquier restricción de licencia sobre el código. Al usar comentarios, debemos asegurarnos de usar comentarios del estilo /* */. Los plugins están en c, y algunos compiladores de c no aceptan comentarios del estilo //.


Código:
/*
Descripción: Este plugin es un ejemplo de plugin de secuencia que filtra píxeles
de baja intensidad. Funciona con un Strip como entrada.
Autor: Kent Mein (mein@cs.umn.edu)
Sitio web: http://www.cs.umn.edu/~mein/blender/plugins
Licencia: Dominio Público
Última modificación: Sun Sep 7 23:41:35 CDT 2003
*/

Después necesitamos rellenar el Nombre, debería ser el mismo que el archivo .c. Preferiblemente descriptivo, menos de 23 caracteres, sin espacios, y todo minúsculas.

Código:
char name[24]= "simpfilt.c";
Cast y varstr necesitan estar sincronizados. Queremos una barra de desplazamiento por lo que haremos lo siguiente:

Código:
varStruct varstr[]= {
 { LABEL, "In: 1 strips", 0.0, 0.0, 0.0, "},
 { NUM|INT, "Intensity", 10.0, 0.0, 255.0, "Our threshold value"},
};

typedef struct Cast {
 int dummy; /* debido al botón 'etiqueta' */
 	int intensity;
} Cast;
Ahora necesitamos rellenar plugin_seq_doit. Basicamente queremos pasar por cada píxel y si RGB es menor que la intensidad seleccionada, coloca el píxel de salida a: 0,0,0,255; si no, devuelve el mismo valor que el píxel de entrada para esa posición.

Código:
int x,y;

 for(y=0;y cast->intensity) &
 (in1[1] > cast->intensity) &
	 (in1[2] > cast->intensity)) {
 out[0] = out[1] = out[2] = 0;
 out[3] = 255;
 } else {
 out[0] = in1[0];
 out[1] = in1[1];
 out[2] = in1[2];
 out[3] = in1[3];
 }
 }
 }
Terminamos pues con simpfilt.c.

Compilando:

bmake es una utilidad simple (shell script) para ayudar a la compilación y desarrollo de plugins, y puede encontrarse en el subdirectorio plugins/ del directorio de instalación de Blender. Se invoca mediante: bmake (nombre_plugin.c) e intentara enlazar las librerías adecuadas y compilar el archivo C especificado adecuadamente para su sistema. Si usted esta intentando desarrollar plugins en una máquina Windows, bmake puede no funcionar en este caso; debería usar lcc. Puede usar lo siguiente para compilar un plugin con lcc, asumiendo que usted tiene sus plugins en c:\blender\plugins: Aquí tiene un ejemplo de cómo se compilaría el plugin de secuencia sweep.c. Abra una ventana DOS y haga lo siguiente: (Nota: Asegúrese de que el directorio lcc\bin esta en su path)


Código:
cd c:\blender\plugins\sequence\sweep
lcc -Ic:\blender\plugins\include sweep.c
lcclnque -DLL sweep.obj c:\blender\plugins\include\seq.def
implib sweep.dll

Nota: Se ha corregido alguna traducción para adaptarla al castellano, gracias a por ofrecernos esta traducción.

Este tutorial esta extraído de en su sitio web podrás encontrar este mismo tutorial traducido a más idiomas.
Blender es un programa gratuito.