|
|
Bienvenido a Foros 3DPoder.. Usted esta viendo este foro como invitado, no esta registrado todavía, lo que limita su visión del foro. Si quiere unirse gratis a la mayor comunidad del diseño gráfico de habla hispana, tener acceso a publicar y responder mensajes, tener mensajes privados con otros miembros(PM), responder encuestas, publicar sus imágenes para que las vea el resto del mundo, tener acceso a los video_tutoriales, y muchas cosas más, no lo dude. Registrarse es rápido, simple y gratuito, agregate hoy a la mayor comunidad 3D de habla hispana! ! Si usted tiene algún problema con su registro, por favor , díganoslo aquí.
|
|
|||||||
12 mar 2008
|
#1 (enlace permanente) |
|
Administrador y fundador.
|
Manual de Blender - XV - EXTENDIENDO BLENDER
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 describirá ambas técnicas. Capítulos
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 Barra de herramientas de texto. El botón Menú (
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 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 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: Código:
>>> import sys >>> print sys.path 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'] 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 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 Código:
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 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 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 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-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. 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 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 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 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() 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.). 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.). 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, 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 estás 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 devolverá 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 dinámicamente, exceptuando que el objeto a cargar se determina cuando se está 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
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 está afectado, en que cantidad, en que manera, etc. Plugins adecuadamente diseñados deberían incluir unicamente 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 unicamente cuando hagan a la textura más facil 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_getversion(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;
}
El primer paso es tener un plan. Para qué sirve este plugin y como los usuarios interactuarán con él. Para este ejemplo crearemos una textura sencilla que crea un simple patrón de ladrillos. Ahora copiaremos nuestro plugin generico 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 deberian 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 brick y el tamaño mortar. El tamaño brick 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"; Código:
#define NR_TYPES 1
char stnames[NR_TYPES][16]= {"Default"};
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, "Brick 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;
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->brick + 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;
}
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 intentará enlazar las librerías adecuadas y compilar adecuadamente para su sistema el archivo C especificado. Si usted está 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 está en su path) Código:
cd c:\blender\plugins\texture\sinus lcc -Ic:\blender\plugins\include sinus.c lcclnk -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:
Interacción con el usuario Blender no tiene ninguna manera de saber cuántas 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 válidos. 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_getversion(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;
}
El primer paso es diseñar un plan de juego. Qué hará este plugin, cómo interactuarán 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, devolverá negro y alfa; de lo contrario devolverá 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"; 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;
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];
}
}
}
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 intentará enlazar las librerías adecuadas y compilar el archivo C especificado adecuadamente para su sistema. Si usted está 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 está en su path) Código:
cd c:\blender\plugins\sequence\sweep lcc -Ic:\blender\plugins\include sweep.c lcclnk -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.
__________________
MUY Importante: Por favor, adjuntar los archivos al foro, ya sean imágenes ó vídeos, un poco mas abajo de la ventana donde se escriben los mensajes, hay un botón "Gestionar Archivos Adjuntos" utilizadlo, gracias. |
|
|
 |
| Usuarios activos actualmente viendo este tema: 1 (0 miembros y 1 visitantes) | |
| Herramientas | |
|
|
Temas Similares
|
||||
| Tema | Autor | Foro | Respuestas | Último mensaje |
| Manual de Blender - PARTE V - ILUMINACION | 3dpoder | Blender | 2 | 11 abr 2008 07:18 |
| Manual de Blender - PARTE XI - RENDERIZADO | 3dpoder | Blender | 0 | 12 mar 2008 09:48 |
| Manual de Blender - PARTE IV - TEXTURAS | 3dpoder | Blender | 0 | 10 mar 2008 15:39 |
| Manual de Blender - PARTE I - INTRODUCCIÓN | 3dpoder | Blender | 1 | 10 mar 2008 08:15 |
| Manual de Blender - PARTE II - MODELADO | 3dpoder | Blender | 0 | 08 mar 2008 16:03 |
|
|
