From BlenderWiki
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 dinámico, tipo de datos dinámicos de muy alto nivel y clases. Python combina un gran poder con una sintaxis muy sencilla. Está 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 está aún en proceso y una mejor integración está 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 está 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 está 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ú.
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 está 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 aparecerá;
- ALT-O - Carga un texto, una Ventana de Selección de Ficheros aparecerá;
- ALT-F - Emergerá la herramienta buscar;
- SHIFT-ALT-F o RMB - Emergerá el Menú Fichero para la Ventana de Texto;
- ALT-J - Emergerá un panel donde puede especificar un número de linea 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 está separado del portapapeles de Windows así que no podrá 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 mostrará 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 http://www.python.org.
Configurando la variable del sistema PYTHONPATH
Asegurate de comprobar en http://www.blender.org 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:
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:\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 está instalado. Esto es sencillo, solo arranque una shell interactiva de Python simplemente abriendo una shell y escribiendo python en ella. Escriba los siguientes comandos:
>>> import sys >>> print sys.path
y anote lo que se muestre por pantalla que debería ser algo como
['', '/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
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 linea. 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 creará polígonos rellenos, no sólo con el perímetro exterior. Para hacer el script aún más completo este exhibirá 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
001 ###################################################### 002 # 003 # Script demostración para la Guia de Blender 2.3 004 # 005 ###################################################S68 006 # Este script genera poligonos. 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, lineas (025-026), con lo que se deben crear dos 'botones genéricos', con sus valores por defecto. Finalmente, los objetos GUI trabajarán con eventos y también los generarán. Los identificadores de los eventos son enteros que serán definidos por el programador. Es una buena práctica utilizar nombres faciles de recordar para los eventos, como se hace en la lineas (029-031).
Dibujando el GUI
El código fuente que se encarga del dibujado del GUI está en la función draw (dibujo) (Dibujando el GUI).
Dibujando el GUI
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 lineas (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 lineas (047-048), 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. Básicamente está 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 creará los polígonos y un botón Exit (Salir).
Manejando eventos
El GUI no se ha dibujado, y no trabajará, hasta que se escriba un manejador de eventos apropiado y se registre (Manejando eventos).
Manejando eventos
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 Q 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
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 vertices 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 vertices 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 linea importante aquí es la número (082). Aquí hay un nuevo objeto malla, donde se crea el poly polígono. El objeto malla está 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) calculará 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 lineas (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 verá como la ventana desaparece y se vuelve gris. En la esquina inferior izquierda el GUI se dibujará (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 pentágono en el plano xy de la ventana 3D (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í está :)
Scripts de Python
Hay más de 100 scripts para Blender disponibles en Internet. Como los plugins, los scripts son muy dinámicos, 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, www.blender.org o www.elysiun.com.
|
![[]](/skins/blender/open.png)
