UNIVERSIDAD NACIONAL EXPERIMENTAL

DE LOS LLANOS OCCIDENTALES

EZEQUIEL ZAMORA
VICE-RECTORADO DE PLANIFICACIN
Y DESARROLLO SOCIAL
PROGRAMA INGENIERA, ARQUITECTURA Y TECNOLOGA
SUBPROGRAMA INFORMTICA

Metodologa Inversa

Integrantes:

Mayerlin Mendoza CI 24322469

Kenen Sols CI 22983049
Profe: Darjeling Silva
Subproyecto: Metodologa del
Desarrollo del Software.
Seccin: 4ESP01N

Barinas, febrero de 2017

BLENDER
Blender es un programa suite libre y abierto de creacin 3D. Es compatible con la
totalidad de la tubera de modelado 3D, aparejos, animacin, simulacin, renderizado,
composicin y seguimiento de movimiento, incluso se puede realizar la edicin de vdeo y
creacin de juego. Los usuarios avanzados emplean API de Blender para secuencias de
comandos de Python para personalizar la aplicacin y escribir herramientas especializadas,
cabe destacar que esto puede realizarse en las futuras versiones de Blender.

Blender es multiplataforma y funciona igual de bien en ordenadores Linux, Windows y

Macintosh. Su interfaz utiliza OpenGL para proporcionar una experiencia coherente. Para
confirmar la compatibilidad especfica, la lista de plataformas soportadas indica los
evaluados peridicamente por el equipo de desarrollo.

Como un proyecto impulsado por la comunidad bajo la Licencia Pblica General de GNU
(GPL), el pblico est facultado para realizar pequeos y grandes cambios en la base de
cdigo, lo que conduce a nuevas caractersticas, correcciones de errores de respuesta y
mayor facilidad de uso. Es importante sealar que Blender tiene ninguna etiqueta de precio,
pero se puede invertir, participar y ayudar a avanzar en una poderosa herramienta de
colaboracin: Blender es su propio software 3D.

Creador e Historia de Blender

Ton Roosendaal es el creador de Blender, la herramienta de cdigo abierto ms grande para
la creacin 3D. Originalmente desarrollado como una herramienta interna, el software est
siendo desarrollado en lnea por una comunidad de desarrolladores dirigidos por Ton
Roosendaal en blender.org.

Ton estudi Diseo Industrial de Eindhoven, antes de fundar el estudio de animacin

NeoGeo, donde Blender se est desarrollando como la herramienta de la casa. En 2000 se
traslad a Amsterdam los Pases Bajos. En 2007 fund el Instituto Blender, donde sigue
trabajando a tiempo completo en proyectos de Blender Open Source.

En 1988, Ton Roosendaal fund el estudio de animacin holands NeoGeo. Este estudio se
convirti rpidamente en la casa ms grande de animacin en 3D en los Pases Bajos.
Dentro de NeoGeo, Ton era responsable tanto de la direccin de arte y el desarrollo de
software interno. Despus de una cuidadosa deliberacin, se decidi que el actual conjunto
de herramientas 3D de la casa tena que ser reescrito desde cero. En 1995 esta reescritura
comenz y estaba destinado a convertirse en la herramienta de software 3D que ahora todos
conocemos como Blender.

En 1998, Ton fund una nueva compaa llamada Not a Number (NaN), para promover el
mercado y desarrollar Blender. El modelo comercial de NaN involucrado el suministro de
productos y servicios comerciales alrededor de Blender. En 2000 la compaa obtuvo la
financiacin del crecimiento por varias compaas de inversin. El objetivo era crear una
herramienta de creacin libre para contenido interactivo en 3D (en lnea) y las versiones
comerciales del software para la distribucin y publishing debido a las decepcionantes
ventas y la difcil situacin econmica actual, los inversores de NaN decidi cerrar todos
operaciones a principios de 2002, este cierre trajo como consecuencia la interrupcin del
desarrollo de Blender.

Ton Roosendaal comenz el primer gol de Blender Fundacin sin nimo de lucro. Blender
fue encontrar una manera de continuar el desarrollo y promocin de Blender como una
comunidad de base proyecto de cdigo abierto.

El domingo 13 de Octubre de 2002, Blender fue liberado al mundo bajo los trminos de la
Licencia Pblica General de GNU. El desarrollo de Blender contina desde ese da
impulsado por un equipo de voluntarios dedicados remotos de todo el mundo dirigido por
el creador original de Blender, Ton Roosendaal. Blender que ha demostrado ser difciles de
organizar y mantener. En lugar de obtener fondos para reunir a los desarrolladores de
software, la Fundacin Blender decidi iniciar un proyecto para reunir a los artistas ms
destacados en la comunidad Blender y retarlos a hacer una pelcula de animacin en 3D
emocionante corto.

Versione Blender
A principios del ao 2008 fue el inicio de las primeras versin de Blender 2.5, una
importante revisin de la interfaz de usuario, las definiciones de herramientas, sistema de
acceso de datos, manejo de eventos, y el sistema de animacin. El objetivo principal era
volver a implementar el ncleo de Blender, originalmente desarrollada a mediados aos 90,
para llevarlo hasta los estndares de interfaz contempornea y mtodos de entrada.

Una primera versin alfa de Blender 2.5 fue presentado el Siggraph 2009. El equipo de
desarrolladores en lnea desde entonces ha enfocado en traer de vuelta a todos los 2.4
funcionalidad y acabado del nuevo diseo de acuerdo a las especificaciones. Con este
trabajo casi terminado ahora, una versin final de 2,5 ha de ser publicados en 2011.

En 2012 se puso el foco en seguir desarrollando y exportando una tubera Visual creacin
de efectos. Los temas que fueron abordados incluyen el seguimiento de movimiento, la
resolucin de la cmara, el enmascaramiento, la clasificacin y el buen conducto de color.
Durante el pasar de los aos se han desarrollado las siguientes versiones de Blender:

Versin 2.57, 2.57a, 2.57b: Abril 2011

Versin 2.58: Junio 22, 2011 / 2.58a: 4 Julio 2011
Versin 2.59: Agosto 14, 2011
Versin 2.60: 19 de de octubre de, 2011
Versin 2.61: El 14 de diciembre de, 2011
Versin 2.62: 16 de de febrero de, 2012
Versin 2.63: Abril 27, 2012 / 2.63a: 10 de Mayo de 2012
Versin 2.64: 3 de octubre de, 2012
Versin 2.65: 10 de de diciembre de, 2012
Versin 2.66: 21o de febrero de, 2013 / 2.66a: 6 de marzo 2013
Versin 2,67 / 2.67a / 2.67b: Mayo 7 / 21/30 de 2013

Versin 2.68: 18 de de julio de, 2013 / 2.68a: 24 de de julio de, 2013

Versin 2.69: 31 Octubre 2013

 Versin 2.70: Marzo 19, 2014 / 2.70a: Abril 10, 2014

Versin 2.71: Junio 26, 2014

Versin 2.72: Octubre 4 2014 / 2.72a: 20 Octubre 2014 / 2.72b: 21 Octubre 2014
 Versin 2.73: Junio 8 2015 / 2.73a: 21 enero el ao 2015

Versin 2.74: 31-Marzo el ao 2015

Versin 2.75a: 1 de julio el ao 2015

Versin 2.76, 9 octubre, 2015 (Actualizacin 2.76b es desde noviembre 3 de 2015

Versin 2.76, 9 octubre, 2015 (Actualizacin 2.76b es desde noviembre 3 de 2015)
 Versin 2.77, Marzo 19 2016 2.77a se llev a cabo el 6 de abril 2016

Versin 2.78a, 30 de de septiembre 2016

Versin 2.78a actualizacin 26 de octubre de 2016

Calidad Tiempo y Respuesta

REQUERIMIENTOS DE SOFTWARE Y HARDWARE
Plataformas compatibles

Blender est disponible para Windows Vista y superior, Mac OS X 10.6 y superior, y Linux
Blender usa OpenGL para dibujar toda la interfaz. 2.7x batidora debe funcionar fuera de la
caja, sin procedimiento de instalacin.

Cabe destacar que estos requisitos son vlidos para Blender 2.77 y ms adelante Sin
embargo,. Blender 2.76 y anteriores todava compatible con Windows XP y OpenGL 1.4
tarjetas grficas.)

(Uso bsico) mnimos de hardware

32 bits de doble ncleo de CPU 2 GHz con soporte SSE2.

2 GB de RAM

24 bits de 1280 768

Ratn o trackpad

OpenGL 2.1 grfica compatible con 512 MB de RAM

Disco duro 320 GB

Hardware recomendado

64-bit CPU de cuatro ncleos

8 GB de RAM

Pantalla Full HD con color de 24 bits

Ratn de tres botones

OpenGL 3.2 grfica compatible con 2 GB de RAM

500 GB

Hardware ptimo (produccin-grado)

64-bit CPU de ocho ncleos

16 GB de RAM

Dos pantallas de alta definicin completa con color de 24 bits

Tableta de tres ratn botn y grficos

Dual OpenGL 3.2 tarjetas grficas compatibles con 4 GB de RAM

Disco duro 1 terabyte

PLANIFICACIN
Anlisis de riesgo

Los riesgos que puedan existir en este programa son pocos ya que debido a sus ltimas
versiones se han corregido todas las posibles fallas que pueden generarse.

Asignacin de Recursos

Estimacin de costes

Para la realizacin de blender se utilizo software libre y OpenGL para su interfaz. Es

importante sealar que Blender tiene ninguna etiqueta de precio, pero se puede invertir,
participar y ayudar a avanzar en una poderosa herramienta de colaboracin.

DESARROLLO
Arquitectura de la aplicacin
Blender fue desarrollado inicialmente dentro de un estudio de animacin, por sus propios
usuarios, y en base a los requisitos que se ajustan a la prctica diaria de la creacin artstica
dentro de los proyectos comerciales; con clientes exigentes y plazos imposibles.

Tiene una estructura estrictamente organizada 'orientado a datos', casi como una base de
datos, pero con algunos aspectos orientados a objetos en el mismo. Fue escrito en su
totalidad en la llanura C. En el diseo de Blender, se hizo un intento para definir estructuras
de manera ms uniforme posible, para todas las posibles representaciones en 3D y para
todas las herramientas universales que realizan los datos (base) de trabajo.

La estructura estaba destinado a permitir a los usuarios y programadores para trabajar con
rapidez y flexibilidad; un mtodo de trabajo que muy adecuado para el desarrollo de un
paquete de diseo y animacin 3D en casa.

Aunque algunos en broma llamado Blender un "struct visualizador ', el nombre es en

realidad bastante precisa. Durante los primeros meses de desarrollo de Blender, hicimos
poco, pero idear estructuras y escribir archivos de inclusin. Durante los aos que
siguieron, sobre todo herramientas y mtodos de visualizacin se elaboraron.

Este diagrama representa la estructura ms bsica de Blender. El ciclo "Visualizar datos de

edicin" est en su ncleo, y se separa de la interfaz grfica de usuario (azul), que funciona
en tres niveles distintivos.

Diagrama Diseo de Cdigo

Estructura de datos
Estructura de datos y punteros C

Las estructuras son normalmente colecciones de variables y de forma que queremos

mantener juntos. Un ejemplo sencillo sera encontrado en la fuente / licuadora / makesdna /
DNA_meshdata_types.h.

/ * Listado de Cdigo de BabyBlend * /

#include <stdio.h>

int principal ( void ) {

/ * estructura de declarar * /
typedef struct MVert {
float co [ 3 ] ; / * Matriz de coordenadas del
vrtice * /
corto sin [ 3 ] ; / * Array de vrtices
normales * /
carbn bandera, mat_nr ; / * Variables de una
bandera y material de ndice * /
} MVert ;

/ * Crear variable de tipo MVert * /

MVert vert ;
Char KEY_PRESS = ' \ 0 ' ;

printf ( " n \ Bienvenido a BabyBlender \ n \ n " ) ;

printf ( "Para crear 'V' un vrtice de prensa \ n " ) ;
printf ( "Key:" ) ;
scanf ( "% c" , y KEY_PRESS ) ;
Interruptor ( KEY_PRESS ) {
caso de 'V' :
caso 'v' :
los valores a la estructura del arreglo * / / *
asignar
printf ( "Introduzca la coordenada X:" ) ;
scanf ( "% f" , y vert. co [ 0 ] ) ;
printf ( "Introduzca la coordenada Y:" ) ;
scanf ( "% f" , y vert. co [ 1 ] ) ;
printf ( "Introduzca la coordenada Z:" ) ;
scanf ( "% f" , y vert. co [ 2 ] ) ;

/ * Imprimir los valores de la matriz de la

estructura * /
printf ( " \ n Su vrtice est se encuentra en \ n "
) ;
 printf ( "X:% f \ n " ., vert co [ 0 ] ) ;
printf ( "Y:% f \ n " ., vert co [ 1 ] ) ;
printf ( "Z:% f \ n " ., vert co [ 2 ] ) ;
romper ;
default : printf ( "Eso no es una opcin \ n " ) ;
}
}

Ejemplo cdigo puntero

/ * Listado de cdigo para BabyBlend2 * /

#include <stdio.h>

int principal ( void ) {

/ * declarar algunas variables de tipo int * /
int a, r, g, b ;
/ * Declarar punteros a tipo int * /
int * alfa, * rojo, * verde, * azul ;
/ * Asignar las direcciones de las variables a los punteros *
/
alfa = & a ; rojo = Y r ; verde = Y g ; azul = y B ;
/ * Valores a las variables utilizando punteros * / asignar
* alfa = 255 ;
* Rojo = 0 ;
* Verde = 128 ;
* Azul = 250 ;

/ * Impresin alfa de datos * /

printf ( " \ n Direccin del puntero alfa% p \ n " , y alfa )
;
printf ( "Direccin de puntero en poder de alfa% p \ n " ,
alfa ) ;
printf ( "Valor en la direccin en manos de alfa% d \ n " , *
alpha ) ;

/ * Impresin roja de datos * /

printf ( " \ n Direccin del puntero rojo% p \ n " , y rojo )
;
printf ( "Direccin en poder de puntero rojo% p \ n " , rojo
) ;
 printf ( "Valor en la direccin en manos de rojo% d \ n " , *
rojo ) ;

* Alfa - = 1 ;
printf ( " \ n * alfa - 1 = \ n " ) ;
printf ( "Direccin de puntero alfa% p \ n " , y alfa ) ;
printf ( "Direccin de puntero en poder de alfa% p \ n " ,
alfa ) ;
printf ( "Valor en la direccin en manos de alfa% d \ n " , *
alpha ) ;
printf ( " n \ valor de aviso en la direccin en manos de
alfa es uno menos \ n " ) ;

alfa + = 1 ;
printf ( " \ n alfa = 1 + \ n " ) ;
printf ( "Direccin de puntero alfa% p \ n " , y alfa ) ;
printf ( "Direccin de puntero en poder de alfa% p \ n " ,
alfa ) ;
printf ( "Valor en la direccin en manos de alfa% d \ n " , *
alpha ) ;
printf ( " \ n Aviso alfa ahora apunta a la direccin en
manos de rojo \ n " ) ;
}

Puntero a estructuras ejemplo de cdigos

* Puntero a la estructura Listado de Cdigo * /

#include <stdio.h>

int principal ( void ) {

/ * estructura de declarar * /
typedef struct MVert {
float co [ 3 ] ; / * Matriz de coordenadas del
vrtice * /
corto sin [ 3 ] ; / * Array de vrtices
normales * /
carbn bandera, mat_nr ; / * Variables de una bandera
y material de ndice * /
} MVert ;

Vert MVert ; / * Crear variable de tipo MVert * /

MVert * vert_point ; / * Crear puntero de tipo MVert * /
carbn KEY_PRESS = ' \ 0 ' ;
 / * Asignar la direccin a la estructura del puntero * /
vert_point = y vert ;

printf ( " n \ Bienvenido a BabyBlender \ n \ n " ) ;

printf ( "Para crear 'V' un vrtice de prensa \ n " ) ;
printf ( "Key:" ) ;
scanf ( "% c" , y KEY_PRESS ) ;
Interruptor ( KEY_PRESS ) {
caso de 'V' :
caso 'v' :
los valores a la estructura del arreglo * / / *
asignar
printf ( "Introduzca la coordenada X:" ) ;
scanf ( "% f" , y ( * vert_point ) . co [ 0 ] ) ;
printf ( "Introduzca la coordenada Y:" ) ;
scanf ( "% f" , y ( * vert_point ) . co [ 1 ] ) ;
printf ( "Introduzca la coordenada Z:" ) ;
scanf ( "% f" , y ( * vert_point ) . co [ 2 ] ) ;

/ * Imprimir los valores de la matriz de la

estructura * /
printf ( " \ n Su vrtice se encuentra en \ n " ) ;
printf ( "X:% f \ n " , vert_point - > co [ 0 ] ) ;
printf ( "Y:% f \ n " , vert_point - > co [ 1 ] ) ;
printf ( "Z:% f \ n " , vert_point - > co [ 2 ] ) ;
romper ;
default : printf ( "Eso no es una opcin \ n " ) ;
}
}

Interfaz de programa de aplicacin API de Blender / Python

Scripts de Python pueden integrar con Blender de las siguientes maneras:

Mediante la definicin de un motor de renderizado.

Mediante la definicin de los operadores.

Mediante la definicin de mens, encabezados y paneles.

Mediante la insercin de nuevos botones en los mens, las cabeceras y paneles existentes
En Python, esto se hace mediante la definicin de una clase, que es una subclase de un tipo
existente.

Ejemplo operador

importacin bpy

def principal ( contexto ):

para ob en contexto . escena . objetos :
print ( ob )

clase SimpleOperator ( bpy . tipos . Operador ):

"" "Informacin sobre la herramienta" ""
bl_idname = "object.simple_operator"
bl_label = "Objeto del operador simple"

@classmethod
def sondeo ( CLS , contexto ):
retorno contexto . active_object es no Ninguno

def ejecutar ( auto , contexto ):

principal ( contexto )
de retorno { 'FINALIZADO' }

def registro ():

bpy . utils . register_class ( SimpleOperator )

def anular el registro ():

bpy . utils . unregister_class ( SimpleOperator )

si __name__ == "__main__" :
registrar ()

# Prueba llamada
bpy . ops . objeto . simple_operator ()

Ejemplo panel
importacin bpy

clase HelloWorldPanel ( bpy . tipos . Panel ):

"" "crea un panel en la ventana de propiedades del objeto" ""
bl_label = "Panel Mundial Hola"
bl_idname = "OBJECT_PT_hello"
bl_space_type = 'Propiedades'
bl_region_type = "ventana"
bl_context = "objeto "

def dibujar ( auto , contexto ):

diseo = auto . diseo

obj = contexto . objeto

fila = diseo . fila ()

fila . etiqueta ( texto = "Hola mundo!" , icono = 'WORLD_DATA' )

fila = diseo . fila ()

fila . etiqueta ( texto = "objeto activo es:" + obj . Nombre )
fila = diseo . fila ()
fila . prop ( obj , "nombre" )

fila = diseo . fila ()

fila . operador ( "mesh.primitive_cube_add" )

def registro ():

bpy . utils . register_class ( HelloWorldPanel )

def anular el registro ():

bpy . utils . unregister_class ( HelloWorldPanel )

si __name__ == "__main__" :
registrar ()
Diseo de las interfaz

Cdigo que genera la interfaz

/ *
Este sistema es crear una API abstracta acceder a estructuras de
malla diferentes. Sus
dividido en tres partes: el modelado, consultas, y el dibujo. Cada
parte se encuentra en su propia
estructura, y las tres estructuras estn incluidos en la
estructura AbstractMesh final.

Los backends de malla en s son necesarios para almacenar todos

los datos bsicos (por ejemplo vrtices
coordenadas, las normales de vrtice / cara, banderas, etc.) como
capas CustomData. los
API CustomData ser rediseado un poco. Va a ser un poco ms
flexible
donde modificadores y herramientas se refiere, por lo que las
herramientas pueden, por ejemplo, aadir un nuevo
banderas a verts / bordes / caras (evitando as que todo el cdigo
que tenemos para hackeado
edgesplit y bisel).

Por cara vrtice datos sern presentados a los usuarios de

AbstractMesh como un nuevo bucle
tipo de elemento. Esto se presenta como un tipo de elemento
geomtrico, sin embargo
back-extremos pueden estar o no en realidad usar bucles en su
propio detrs de las escenas
implementaciones.

Cada vert / borde / cara se har referencia por un intptr_t-

backend especfico, una
nmero entero que puede almacenar un puntero tambin. Estos
enteros se pueden utilizar para recuperar
Resumen *** envoltorios iterador. Estas envolturas iterador
contienen punteros a servicios pblicos
diversos CustomData (tales como la ubicacin vrtice, vrtice
normal, etc). Tambin habr
ser una interfaz para acceder a las capas CustomData primas que
utilizan estos intptr_ts.

Cada backend tendr una mscara de bits que especifica cul de

varias interfaces opcionales
que da soporte, tal como una interfaz de adyacencia de consulta.
Siempre deber
ESTA BITMASK !!

El uso de este sistema, que debera ser posible escribir una sola
funcin que se
convertir de un back-end a otro. Tales conversiones slo deberan
producirse como
absolutamente necassary, como por herramientas que requieren
bmesh.
* /

struct AbstractVertIterator ;
struct AbstractEdgeIterator ;
struct AbstractLoopIterator ;
struct AbstractFaceIterator ;

typedef struct AbstractDrawer {

/ ** /
void ( * drawFaces ) ( void * auto, int layermask ) ;
void ( * drawEdges ) ( void * auto ) ;

/ * esto es para el material por ejemplo el modo de halo

* /
void ( * drawPoints ) ( void * auto ) ;

/ * Llamada de retorno para la seleccin de malla de dibujo

en modo edicin,
debe basar ndices fuera de la capa ORIGINDEX si
existe (por ejemplo, no estamos operando en el original
. mesdata, estamos en el modo de modificador) * /
void ( * drawBackbufferSelect ) ( void * auto ) ;

/ * stas son las funciones reales de dibujo editmesh * /.

void ( * drawMappedTranspFaces ) ( void * auto ) ;
void ( * drawMappedFaceDots ) ( void * auto ) ;
void ( * drawMappedEdges ) ( void * auto, int do_interp )
;
void ( * drawMappedVerts ) ( void * auto ) ;
} AbstractDrawer ;

/ * AbstractDrawer-> drawFaces layermask argumento * /

#define ADL_SHADED 1
#define ADL_TEXTURE 2
#define ADL_GLLIGHT 4
#define ADL_VCOL 8
/ * para el dibujo pintura peso, supongo, no est seguro de cmo
debera funcionar * /
ADL_WCOL #define 16

/ * Cada una de estas operaciones de trabajo en

"Etiquetados" elementos, etiquetados a travs
las funciones de etiquetado, que
vivir aqu y no en la consulta
. interfaz * /
typedef struct AbstractModeler {
/ * asegurar que tenemos informacin de adyacencia * /.
void ( * ensureAdjacencyInfo ) ( void * auto ) ; .

/ * Tiras informacin de adyacencia. debe devolver siempre

xito, incluso en back-ends sin adyacencia
. * Informacin /
void ( * stripAdjacencyInfo ) ( void * auto ) ;

/ * Preparacin de devolucin de llamada llamada antes de

realizar
cualquier operacin de modelado. No se olvide de llamar
endModeling eplogos.

* Ensure_adj: pasando un valor distinto de cero a

ensure_adj
tendr beginModeling llamar ensureAdjacencyInfo.
* /
Void ( * beginModeling ) ( void * auto, int ensure_adj ) ;

. / * Funcin de llamada llama cuando ha terminado una

operacin * /
void ( * endModeling ) ( void * auto, int strip_adj ) ;

/ * Funciones de etiquetado para etiquetar verts / bordes /

caras para varios
. * operaciones /
void ( * resetTagging ) ( void * auto, int doverts, int
doedges, int dofaces ) ;

/ * Estado es el valor de la etiqueta, puede ser 0 o 1. 0

se borra el
. Estado de etiquetas, mientras que 1 establece que * /
 void ( * tagVert ) ( void * auto, intptr_t vert, int
estado ) ;
void ( * tagEdge ) ( void * auto, intptr_t borde, int
estado ) ;
void ( * tagFace ) ( void * s, cara intptr_t, int estado
) ;

/ * Esto duplica todos los elementos marcados, preservando

las etiquetas de los elementos copiados, pero la
eliminacin de ellos
a partir de los elementos de la fuente * /.
void ( * duplicateTaggedElements ) ( void * auto ) ;
void ( * findDoubles ) ( void * auto, flotador lmite,
intptr_t ** source_target_pais,
int ** totvert ) ;
void ( * soldadura ) ( void * auto, intptr_t *
source_target_pairs, int totvert ) ;
/ * simples (no alado) del borde de extrusin * /
void ( * extrudeEdges ) ( void * auto ) ;
void ( * extrudeFaceRegions ) ( void * auto ) ;
void ( * extrudeFaces ) ( void * auto )

/ * Cada una de estas declaraciones de un identifyer

intptr_t al nuevo elemento.
NOTA:. No puede crear o destruir directamente bucles * /
intptr_t ( * makeVert ) ( void * auto, intptr_t *
returnvert, flotar * co, flotar * no, cortos banderas,
intptr_t data_to_copy ) ;
intptr_t ( * makeEdge ) ( void * auto, intptr_t * retedge,
intptr_t v1, v2 intptr_t,
intptr_t data_to_copy ) ;
intptr_t ( * makeFace ) ( void * auto, intptr_t * retface,
intptr_t * verts, int len,
intptr_t data_to_copy ) ;

/ * elimina etiquetada Verts / bordes / caras * /

void ( * deleteVert ) ( void * auto, intptr_t vert ) ;
void ( * deleteEdge ) ( void * auto, intptr_t borde ) ;

/ * borrar los datos asociados por cara * /.

void ( * deleteFace ) ( void * s, cara intptr_t ) ;

void ( * recalcNormals ) ( void * auto ) ;

} DerivedModeler ;
/ * Todos / EDGE / bucle / datos faciales vert se consulta a
travs de este sistema de "repetidor".
Cada repetidor almacena todos los datos necesarios para un tipo
de elemento. estos iteradores
se puede utilizar como contenedores genricos para los datos
vert / EDGE / bucle / cara. Asignacin
de ellos puede ser manejado por preasignar un nmero limitado de
ellos en una piscina,
sortof similar a una pila bsica del programa.

Tenga en cuenta que muchos de estos "iteradores" contener

punteros convienence a la activa
capas de datos personalizados, tales como informacin de textura
UV, las ubicaciones de los vrtices, etc.
Tales indicadores apuntan siempre a los datos en la capa de
datos personalizado * * activa de
su tipo. Si desea que los datos de otras capas, se utiliza la
consulta CustomData
API.
* /

typedef struct AbstractIterator {

/ * backend-ID especfico, puede ser un ndice, un puntero,
etc. * no * es un ID de elemento * /.
Identificacin del intptr_t ;

/ * indicador establecido cuando iteracin termina * /

int at_end ;

/ * Set cuando se marca un elemento, tenga en cuenta que

este
es esencialmente slo lectura, para establecer el estado
de la etiqueta
utilizar las funciones de marcado * /.
int is_tagged ;
Itervoid de error ;

/ * lanzamiento este iterador * /

void ( * liberacin ) ( void * malla, void * auto ) ;

/ * Sustituye los datos en esta iterador con el siguiente

elemento de la
. * flujo /
void ( * siguiente ) ( void * malla, void * auto ) ;
} AbstractIterator ;
/ * Accede a la informacin vert. Tenga en cuenta que el prximo
puede modificar simplemente auto
y devolverlo * /.
typedef struct AbstractVertIterator {
AbstractWrapper principal ;

/ * Cuenta que estos son punteros convienence, todos estos

datos es
. almacenada como CustomData * /
float * co, * no ;
MDeformVert * DVERT ;

/ * Devuelve un iterador capaz de iterar sobre los bordes

alrededor de un vert * /.
AbstractEdgeIterator * ( * getEdge ) ( void * malla, void
* auto ) ;
} AbstractVertIterator ;

typedef struct AbstractEdgeIterator {

AbstractWrapper principal ;

/ * Recuerde, pliegue es una capa CustomData igual

. todo lo dems * /
float * pliegue ;

/ * banderas es tambin una capa CustomData * /.

AbstractFlags * banderas ;

/ * Estos podran ser sustituidos por los ndices de IDS /

elemento (lo que las
decidimos utilizar) * /.
AbstractVertIterator * ( * getV1 ) ( void * malla, void *
auto ) ;
AbstractVertIterator * ( * getV2 ) ( void * malla, void *
auto ) ;

/ * Adyacencia cosas, siempre se debe comprobar para

asegurarse de que la
abstractmesh apoya esta * /.
AbstractVertIterator * ( * nextRadialAroundV1 ) ( void *
malla, void * auto ) ;
AbstractVertIterator * ( * nextRadialAroundV2 ) ( void *
malla, void * auto ) ;
 AbstractVertIterator * ( * firstFaceAroundEdge ) ( void *
malla, void * auto ) ;
} AbstractEdgeIterator ;

/ * accesos bucles. Tenga en cuenta que el prximo puede modificar

uno mismo y devolverlo * /.
Typedef struct AbstractLoopIterator {
AbstractWrapper principal ;

/ * col UV activa * /
float ( * uv ) [ 2 ] , ( * col ) [ 2 ] ;

/ * Adyacencia cosas, siempre se debe comprobar para

asegurarse de que la
abstractmesh apoya esta * /.
AbstractFaceIterator * ( * getFace ) ( void * malla, void
* auto ) ;
AbstractVertIterator * ( * getVert ) ( void * malla, void
* auto ) ;
AbstractEdgeIterator * ( * getEdge ) ( void * malla, void
* auto ) ;
} AbstractLoopIterator ;

typedef struct AbstractFaceIterator {

void * de datos, * siguiente, * CustomData ;
/ * backend-ID especfico, puede ser un ndice, un puntero,
etc, es * no * es un ID de elemento * /.
Identificacin del intptr_t ;

Verts AbstractVertIterator ;
AbstractEdgeIterator bordes ;
AbstractLoopIterator bucles ;

flotar * normales ;
int * colchoneta ;
} AbstractVertIterator ;

typedef struct AbstractQuery {

int ( * hasAdjacencyInfo ) ( void * auto ) ;

AbstractFaceIterator * ( * iterFaces ) ( void * auto ) ;

AbstractEdgeIterator * ( * iterEdges ) ( void * auto ) ;
AbstractVertIterator * ( * iterVerts ) ( void * auto ) ;
 / * Backbuffer seleccione los necesitar. No deben ser
usados
por ninguna otra cosa. Las funciones empezarn /
endSelectPicking son tan
el back-end puede preparar varias optimizaciones, si es
necesario,
antes de tener que procesar una gran cantidad de recoger las
bsquedas de ndice.
Ellos son opcionales, y no debe ser el uso si simplemente
recogiendo
algunos elementos (como durante RIGHTMOUSE Seleccin
normal). * /
Void ( * beginSelectPicking ) ( void * auto, int doverts,
int doedges, int dofaces ) ;
AbstractVertIterator * ( * getVertAtIndex ) ( void * auto,
int index ) ;
AbstractEdgeIterator * ( * getEdgeAtIndex ) ( void * auto,
int index ) ;
AbstractFaceIterator * ( * getFaceAtIndex ) ( void * auto,
int index ) ;
void ( * endSelectPicking ) ( void * auto ) ;

/ * Obtener vert / EDGE / bucle / enfrentan iterador

descriptiva de un backend-specfic
. intptr_t valor * /
AbstractVertIterator * ( * getVert ) ( void * auto,
intptr_t ref ) ;
AbstractEdgeIterator * ( * getEdge ) ( void * auto,
intptr_t ref ) ;
AbstractLoopIterator * ( * getLoop ) ( void * auto,
intptr_t ref ) ;
AbstractFaceIterator * ( * getFace ) ( void * auto,
intptr_t ref ) ;
} AbstractQuery ;

typedef struct AbstractMeshType {

AbstractDrawer * cajn ;
AbstractModeler * modelo ;
AbstractQuery * consulta ;

/ * debe liberar a todos los datos relacionados * /.

void ( * liberacin ) ( void * auto ) ;
void * ( * newMesh ) ;
 / * ------- ------- Cosas CustomData interna * /

/ * Aade una nueva capa de tipo tipo. Si el nombre se pasa

como NULL, se utiliza el nombre predeterminado.
asigna automticamente capa con el tamao adecuado, por
pruebas de que los datos (vertData, faceData,
etc) fue aprobada en * /.
void ( * customdata_add_layer ( void * auto, CustomData *
de datos, int tipo, Char * Nombre ) ;
void ( * customdata_rem_layer ) ( CustomData * de datos,
int tipo, int subcapa, int can_free, int free_all ) ;
void ( * customdata_set_active_layer_index ) ( CustomData *
de datos, int tipo, int subcapa, int set_render ) ;
void ( * customdata_set_active_layer ) ( CustomData *
datos, int tipo, CustomDataLayer * subcapa, int set_render ) ;

void ( * customdata_copy_data ) ( CustomData * fuente,

CustomData * dest, src_index intptr_t, intptr_t
dst_index ) ;

void ( * customdata_merge_data ) ( CustomData * fuente,

CustomData * dest, src_index intptr_t, intptr_t
dst_index ) ;

/ * Estos dos obtener prxima CustomData especfica de los

elementos. El primero de ellos volver
datos de la capa activa en ese momento, mientras que el
segundo permite escoger la subcapa
de usar * /.
void * ( * customdata_get_active_data ) ( intptr_t datos,
int tipo ) ;
void * ( * customdata_get_data_at_index ) ( intptr_t datos,
int tipo, int subcapa ) ;

void ( * customdata_interp ) ( CustomData * de datos,

intptr_t * src_refs, flotar * pesos,
int conteo,
intptr_t dest_block ) ;

} AbstractMeshType ;

typedef struct AbstractMesh {

AbstractMeshType * Tipo ;

/ * Mscaras de todas las capas de datos personalizados

 Actualmente almacenada en esta malla * /.
int CD_VertDataMask ;
int CD_EdgeDataMask ;
int CD_LoopDataMask ;
int CD_FaceDataMask ;

int IM_InterfaceMask ;
} AbstractMesh ;

/ * ops banderas de modelado * /

#define IM_WELD (1 << 0)
IM_EXTRUDEFACES #define (1 << 1)
#define IM_EXTRUDEFACEREGION (1 << 2)
IM_EXTRUDEEDGES #define (1 << 3)
IM_EXTRUDEVERTS #define (1 << 4)
IM_RECALCNORMALS #define (1 << 5)

/ * banderas informacin de adyacencia de consulta * /

#define IM_EDGES_AROUND_VERT (1 << 6)
#define IM_FACES_AROUND_EDGE (1 << 7)

Pruebas

MANTENIMIENTO
Cambios en los entornos y correccin de errores

Cambios en los requisitos

 ESTILO DE ARQUITECTURA
Estructura externa del sistema

La estructura con la que trabaja Blender est orientada a objetos, esto quiere decir que en
cada uno de los elementos que usamos blender podemos mover, rotar o modificar, son
tratados como entidades independientes, reconocibles y reusables, que a su vez pueden ser
agrupados para interactuar con ellos de manera conjunta a travs de enlaces.

Los objetos no son ms que bloques de informacin que es interpretadas por Blender para
representar lo que vemos, as podemos distinguir entre los siguientes:

La Escena: Que es el lienzo del mundo 3D que contiene informacin especfica para el
rendir (cmara, resolucin de imgenes) y las referencias a los otros objetos. Escenas
diferentes pueden usar los mismos objetos, y se pueden enlazar distintas escenas, para
formar un decorado.

El mundo: Contiene variables de entorno.

Objetos: Contiene la informacion para definirlo (llamados datablocks): posicin, rotacin,

tamao y matrices de transformacin. Puede enlazarse a otros objectos para formar
jerarquias o deformaciones. Los objetos pueden estar vacios o enlazarse a la informacin
3D propiamente dicha: Malla, Curvas, Fuentes de Luz, etc. y pueden enlazarse a curvas de
animacin y a materiales. Los objetos bsicos disponibles en Blender son plano, cubo,
cono, circulo, plano, tubo, cilindro, icoesfera ( una esfera hecha de tringulos), UVEsfera
(esfera hechas con segmentos (verticalmente) y anillos(longitudinalmente), a ms
segmentos y anillos, ms suavidad) y una cabeza de mono, que es uno de esos huevos de
pascua que suelen dejar los programadores, y representa la mascota de Blender.

Malla: (mesh en ingls), es un grupo de tringulos y cuadrilateros formando una malla.

Contiene vrtices, caras, y vectores normales (aquellos perpendiculares a la superficie en
ese punto). Puede tener un bloque de cuadro clave para morphing. Puede enlazarse a
materiales.
 Curva (curves en ingls) son datos que representan curvas de Bezier, BSplines, y Nurbs 3D
Surfaces, y tambin representan texto. Tambin pueden tener una estructura de cuadro clave
y puede enlazarse a materiales.

Material: contiene propiedades visuales tales como colores, reflectividad y transparencia.

Puede enlazarse a texturas diferentes.

Texturas: Contiene la informacin sobre imgenes que se colocan sobre los objetos. Pueden
enlazarse a materiales, fuentes de luz y Mundo.
Fuentes de luz (lamps en ingls) ,datos que se usan para representar la luminosidad, as
como valores de colores y sombras. Se puede enlazar a las texturas

Ipo: (abreviatura de InterPolation Object) ,es el sistema principal de curvas de animacin.

Se pueden usar con los objetos para darles movimiento o animacin.

Interfaz

El rea y el ratn

Lo primero que vemos tras ejecutar el blender es esta pantalla de aqu abajo.

Navegando por el mundo 3D

La ventana ms grande que podemos ver en la imagen, la que tiene la malla con un par de
elementos, se conoce como ventana 3D (3DWindow). En ella podemos ver:

La malla o rejilla, que es un plano dividido en cuadrculas que nos servir como referencia
y ayuda para situar los objetos en el mundo3D.

Una cmara, que es la pirmide con un punto amarillo en su extremo.

Un cuadrado rosa, que en realidad es un cubo visto desde arriba, y es rosa porque est
seleccionado, si no aparecer con las lineas negras.

Una fuente de luz, que es el circulo amarillo con otro dentro, es lo que le dar luz a nuestros
objetos.

El cursor 3D, que es la cruz que tiene un crculo rojo y blanco. Nos servir para hacer los
movimientos de los objetos en base a su situacin y para que aparezcan en donde est
situado cuando los creemos. Lo podemos colocar donde queramos si hacemos LMB en un
punto de la ventana3D si no tenemos nada seleccionado.