Programación de aplicaciones RV

Bibliografía Programación de aplicaciones RV TÉCNICAS Y DISPOSITIVOS DE REALIDAD VIRTUAL MASTER EN INFORMÁTICA GRÁFICA, JUEGOS Y REALIDAD VIRTUAL Marcos García Marcos.garcía@urjc.es Virtual Reality Technology Ed. Wiley-Interscience (Second Edition). Grigore C. Burdea & Philippe Coiffet. The Inventor Mentor : Programming Object-Oriented 3D Graphics with Open Inventor, Release 2 Ed. Wesley. Josie Wernecke. The Inventor Toolmaker : Extending Open Inventor, Release 2 Ed. Wesley. Josie Wernecke. Open Inventor C++ Reference Manual Ed. Wesley. Josie Wernecke. http://doc.coin3d.org/ http://oss.sgi.com/projects/inventor/genfaq.html http://wwwasd.web.cern.ch/wwwasd/lhc++/openinvent or/pro/html/inventor_base.htm Índice Estructura de un sistema RV Introducción OpenInventor EonStudio

Estructura software de un sistema RV Estructura software de un sistema RV Usuario Dispositivos Entrada Software Entrada Motor Software Dispositivos Salida Software Salida Sw Modelo de mundo virtual Geometría Dotar de comportamiento a los objetos del modelo Introducir el modelo de forma organizada en nuestra aplicación Comportamiento Crear módulos que gestionen los dispositivos I/O Render Gráfico OpenGl DirectX Render Háptico Drivers de los dispositivos Toolkits Estado Mundo Virtual Base de Datos VR Toolkits Características adicionales Soportan algunos dispositivos I/O Permiten generar código portable Permiten importar (y exportar) modelos en formatos usados por herramientas CAD (.3ds,.max,.dwg,.dxf). Detección de colisiones Simulación física Animación de personajes. Modelos de texturas, iluminación y sombreado Soporte de modelos multirresolución (LOD) Funciones de red para interacciones multiusuario Clasificación Programación gráfica o de texto Lenguaje de programación que usan Dispositivos soportados (I/O) Rendering soportado Propósito especifico o propósito general Propietarias o públicas

Clasificación Nombre Open Inventor (SGI,COIN3D,TGS) EON Studio (Eon Reality) Área de aplicación Propósito general Propósito general Librerías propietarias Si/No Si Lenguaje de la librería C/C++ 3DVIA Virtools Propósito general Si Scripting Java3D (Sun Microsystems) GHOST (SensAble Technologies) Propósito general/render Gráfico Renderizado Háptico No Si Programación gráfica SDK C++ (Extender e integrar) Java C++ Actualmente Toolkits de Render y Motores Completos Crytek Ogre Unity3D Unreal Engine Sofa (aplicaciones quirurjicas) Toolkits de sonido DirectSound OpenAl Toolkits de Simulación Física Havok Physics Engine PhysX Bullet Ode Toolkits de Inteligencia Artificial Kynapse 4.0 (PS3) PeopleShop (Boston Dynamics) Militar/Civil Si C/C++ Scene Graphs Scene Graphs Las toolkits organizan la información en grafos llamados scene graphs Organizan el mundo de forma jerárquica Estructura de árbol Nodo raíz Internos Hoja La forma de leer el árbol es propia de cada toolkit No son estructuras fijas Ejemplos: B D Nodo root A C E Nodo Interno J Nodo Hoja F G H I

Scene Graphs Ejemplos: Escena Open Inventor Palma Bola Índice Introducción Arquitectura de OI Base de Datos (primitivas) Componentes de alto nivel Grafo de escena Jerarquía de objetos Implementaciones de Open Inventor Introducción Toolkit 3D C/C++ Orientada a objetos Extensible Aprovecha toda la potencia Hw. Código portable Tiene su propio formato de intercambio de datos *.iv = *.wrl Permite el intercambio de datos entre aplicaciones

Introducción Características adicionales (Coin) Soporte sonido 3D Detección de colisiones Soporte threads Orientada a objetos Soporte: 3DS Visualización de volúmenes (Sim Voleon) Otros módulos Introducción Clases básicas Primitivas Nodos de propiedad, forma, grupo Manipuladores Node Kits Engines (Motores) Sensores Acciones Componentes de alto nivel Arquitectura de Inventor Arquitectura de Inventor Open Inventor Component Library Node kit Manipulator Database Scene Open Inventor 3D Toolkit Open Inventor 3D Interchange File format Open Inventor 3D Interchange File format OpenGL SSOO

Base de datos Librería de componentes Contiene Nodos Agrupados en Scenegraphs Motores Sensores Permite Acciones Renderizado Búsquedas Cálculo de Bounding Box (caja contenedora) Escritura y lectura de un archivo Librería de componentes Dependiente del gestor de ventanas Contiene Áreas de Renderizado Visualizadores Editores Realiza la inicialización (Base de datos y sistema de ventanas) Trata eventos Los captura Los trata directamente Los transforma para OI Scene Graph Nodos del grafo de la escena La unidad básica de OI son los nodos Los nodos se estructuran en grafos Tienen una estructura muy parecida a los árboles Nodo raíz (nodo de agrupación) Nodos intermedios (nodo de agrupación) Nodos hojas (propiedades, formas, manipuladores..) Un nodo hijo pude tener dos padres El grafo debe ser acíclico

Ejemplo de DB Lectura del grafo Escena 1 Escena 2 Aplicar acción Arriba a bajo De izquierda a derecha Traversal state (estado trasversal) Acumulación de transformaciones Material Luces Ejemplo de DB Objetos OI Escena 1 Escena 2 Convención de nombres Objetos Comienzan por S mayúscula y el comienzo de cada palabra irá también en mayúscula Objetos básicos Sb (scene basic)» SbVec3f Resto de objetos So (scene objet)» SoGroup Objeto de la librería de componentes So[Gestor de ventanas]» SoWinRenderArea, SoQtRenderArea, SoXtRenderArea Métodos y atributos Primera letra con minúscula, y el comienzo de cada palabra en mayúscula addchild() Tipos enumerados Todo en Mayúscula FILLED, FIRST

Jerarquía de objetos Base de datos Objetos Básicos (Sb) Campos (Fields) Mono-valuados (Single-field SoSF) Multi-valuados (Multi-field SoMF) Objetos heredados de la clase base SoBase Contenedores de Campos SoFieldContainer Motores SoEngine Nodos SoNode Forma Propiedad Grupo Kits Iluminación Cámaras Rutas SoPath Sensores SoSensor Tiempo SoTimerQueueSensor Otros SoDelayQueueSensor Acciones SoAction Errores SoError Eventos SoEvent Base de Datos SoBD Estado SoState (SoElement) Librería de componentes SoXt, SoWin SoWinObject Componentes (Ventanas) Dispositivos Contiene los grafos de escena (nodos), los motores y los sensores. Tiene un modelo de eventos independiente del gestor de ventanas Es un objeto único SoDB Ha de ser inicializado Directamente SoBD::init() Inicializando la librería de componentes: SoWin::init() Permite utilizar el formato de intercambio de datos SoSeparator *readall(soinput *fichero) Ejemplo Objetos básicos SoSeparator *readfile(const char *filename) SoInput * datafich = new SoInput(); SoSeparator *sep; if (!datafich->openfile (filename)) fprintf (stderr,"error: Abriendo generando la base de datos\n" " ->No se encuentra el fichero %s\n",filename); exit (-1); //Comprobamos que es un fichero válido if (!datafich->isvalidfile ()) fprintf (stderr,"error: Abriendo generando la base de datos\n" " ->Fichero %s no valido\n",filename); exit (-1); Objetos Básicos (Sb) Tipos básicos, no tienen ningún objeto padre en la jerarquía. Usados por otros objetos OI Ejemplos SbLine, SbName, SbVect3f, SbRotation, SbMatrix, SbViewportRegion, SbMutex sep=sodb::readall (datafich); delete datafich; return sep;

Campos (Fields) SoType Contenedores (Fields) Contienen tipos básicos Básicamente se usan para detectar cambios en los campos de la base de datos. Campos mono-valuados (Single-field SoSF) SoSFFloat (float), SoSFRotation (SbRotation) Campos multi-valuados (Multi-field SoMF) SoMFFloat (float), SoMFRotation (SbRotation) Asignación de valores y consulta de valores Mono-valuados Asignación normal: SoSFFloatVar = 3.0f; Uso de los métodos setvalue y getvalue Multi-valuados Como si se tratase de un vector: SoSFFloatVar [1]= 3.0f; Uso de los metodos: getvalue, set1value, setvalues, insertvalues, deletevalues Indica el número de valores que posee: getnum Se pueden conectar: connectfrom() Se pueden ignorar: setignore Clase de chequeo de tipos SoBase, acciones, eventos, errores SoType permite Obtener el nombre del tipo getname() Crear instancias createinstance() Conocer el clase padre getparent() Conocer el tipo de un nodo por su nombre fromname() Utilidad: saber si un objeto pertenece a una determinada clase o jerarquía Objeto->getTypeId.isDerivedFrom(SoXXXX::getClassTypeID) Objeto->isTypeOf(SoXXXX::getClassTypeID) Objeto->getTypeId==SoXXXX::getClassTypeID Permite realizar búsquedas de un determinado tipo (SoSearchAction) Equivalentes Ejemplo Objetos heredados de la clase base SoBase SoSearchAction mysearchaction; // Look for first existing light derived from class SoLight mysearchaction.settype(solight::getclasstypeid()); mysearchaction.setinterest(sosearchaction::first); mysearchaction.apply(root); if (mysearchaction.getpath() == NULL) // No lights found // Add a default directional light to the scene SoDirectionalLight *mylight = new SoDirectionalLight; root->insertchild(mylight, 0); Contenedores de Campos Nodos Forma Propiedad Transformaciones» Manipuladores Apariencia Métricos Grupo Kits Iluminación Cámaras Motores Rutas

Creación de nodos Borrado de nodos Los nodos deben crearse como punteros Deben ser referenciados en la base de datos Directamente ref() Añadiéndolo a un padre addchild(), insertchild() Añadiéndolo a un path o ruta SoPath Añadiéndolo a una lista de nodos SoNodeList Añadiéndolo a un campo o field SoSFNodo SoMFNode Conectándolo de un engine No usar delete DECREMENTAR a 0 su contador de referencias (cada operación decrementa en 1 este contador) De forma directa unref() Borrándolo de un nodo padre deletenode() Sacándolo de un path o ruta SoPath Borrándolo de una lista de nodos SoNodeList Cambiando el puntero de campo o field a NULL o con otro valor SoSFNodo SoMFNode Desconectándolo de un engine Quitar referencias sin borrar Nombrado de nodos y motores Se utiliza unrefnodelete() Ejemplo Incorrecto Creas un nodo: new SoCone() Le aplicas una acción (ref/unref) : SoBoundingBoxAction Lo añades a un grupo: addchild() Correcto Creas un nodo new SoCone() Lo referencias: ref Le aplicas una acción: SoBoundingBoxAction Usas unrefnodelete() Lo añades a un grupo: addchild() Descendientes de la clase SoBase Obtener nombre getname() Poner nombre setname() Buscar nodo por nombre SoNode::getByName ()

Ejemplo Tipos de nodos SoSeparator *root = new SoSeparator; root->ref(); //Importante referenciar el nodo raíz root->setname("root"); SoCube *mycube = new SoCube; root->addchild(mycube); mycube->setname("mycube"); SoSphere *mysphere = new SoSphere; root->addchild(mysphere); mysphere->setname("mysphere"); RemoveCube(); --------------------------------------------------------------------------------------------------------- void RemoveCube() //Busca en toda la base de datos, no sólo en una escena SoSeparator *myroot; myroot = (SoSeparator *)SoNode::getByName("Root"); SoCube *mycube; mycube = (SoCube *)SoNode::getByName("MyCube"); myroot->removechild(mycube); Forma Propiedad Transformaciones Manipuladores Apariencia Métricos Grupo Iluminación Cámaras Nodos de forma Nodos de propiedad SoShape Formas básicas SoSphere, SoCylinder, SoCone Curvas y superficies (Nurbs) Indexadas SoIndexedNurbsCurve, SoIndexedNurbsSurface No Indexadas SoNurbsCurve, SoNurbsSurface Textos 3D y 2D SoText2, SoText3 Formas compuestas por vértices Indexadas SoIndexedFaceSet, SoIndexedLineSet, SoIndexedTriangleStripSet, No Indexadas SoFaceSet, SoPointSet, SoLineSet, SoQuadMesh, SoPointSet, SoMarkerSet VRML Nodos de transformación (SoTransformation) SoTranslation, SoRotation, SoScale SoTransform SoTransformManip (Manipuladores) Nodos métricos Nodos métricos SoNormal, SoCoordinate3

Nodos de apariencia Color SoMaterial SoBaseColor Textura SoTexture2 Tipo de letra SoFont Nodos de grupo Son contenedores que agrupan nodos de la escena Su clase base es SoGroup. Métodos básicos addchild insertchild removechild (Índice o nodo) Subclases: SoSeparator SoSwitch (whichchild) SoTransformSeparator Nodos de iluminación y nodos cámara Iluminación: iluminan la escena SoGLLightIdElement::getMaxGLSources(); //nº máx luces SoLight Ambiental Puntual (Point) Direccional (Directional) Focal (Spot) Cámara: Muestran parte de la escena SoCamera Proyección en perspectiva Proyección ortográfica Frusturm Modelo de Eventos Derivan de la clase SoEvent Son enviados por la librería de alto nivel Eventos de teclado, ratón Se recorre el árbol de escena buscando qué nodos pueden tratar el evento sethandled Nodos que tratan eventos Manipuladores SoSelection SoEventCallback

Manipuladores Callbacks Draggers y manipulators. Son nodos que capturan eventos y tienen determinadas respuestas ante ellos. Funcionamiento Capturan el evento Cambian de forma Los manipuladores además son nodos de propiedad Cambian el traversal state Luces Transformaciones Planos de corte Se pueden sustituir por transformaciones o luces replacenode (SoPath *p) replacemanip (SoPath *p, SoTransform *t) Son funciones a las que se llama cuando un objeto detecta un evento Nodos (SoCallback, Draggers, SoEvenCallback, SoSelection ) Sensores Motores Es una forma de dotar de comportamiento a la escena Ejemplo: SoSelection *grupo= new SoSelection(); grupo->addselectioncallback(seleccioncallback, data); void seleccioncallback(void *userdata, SoPath * path); Ejemplo Ejemplo // An event callback node so we can receive key press events SoEventCallback *myeventcb = new SoEventCallback; myeventcb ->addeventcallback(sokeyboardevent::getclasstypeid(), mykeypresscb, selectionroot); selectionroot ->addchild(myeventcb); -------------------------------------------------------------------------------------------- // userdata is the selectionroot from main(). Void mykeypresscb(void *userdata, SoEventCallback *eventcb) SoSelection *selection = (SoSelection *) userdata; const SoEvent *event = eventcb->getevent(); If (SO_KEY_PRESS_EVENT(event, UP_ARROW)) myscaleselection(selection, 1.1); eventcb->sethandled(); else if (SO_KEY_PRESS_EVENT(event, DOWN_ARROW)) myscaleselection(selection, 1.0/1.1); eventcb->sethandled(); SoEventCallback * ecb = new SoEventCallback; ecb->addeventcallback(soevent::getclasstypeid(), mouse_cb, NULL); root->addchild(ecb); ------------------------------------------------------------------------- void mouse_cb(void * closure, SoEventCallback * eventcb) const SoEvent * event = eventcb->getevent(); if (event->isoftype(solocation2event::getclasstypeid())) const SbVec2s position = event->getposition(); printf("mouse moved: <%i %i>\n", position[0], position[1]);

Ejemplo CDS SoEventCallback * mouseevent = new SoEventCallback; mouseevent-> addeventcallback(somousebuttonevent::getclasstypeid(), mousecallback,null); root->addchild (mouseevent); SoEventCallback * keyevent = new SoEventCallback; keyevent -> addeventcallback(sokeyboardevent::getclasstypeid(), keycallback,null); root->addchild (keyevent); -------------------------------------------------------------------------------------------- void mousecallback (void *, SoEventCallback *mouseevent) const SoEvent *event = mouseevent->getevent (); if (SO_MOUSE_PRESS_EVENT(event, BUTTON1)) //OTRAS MACROS. //SO_KEY_PRESS_EVENT (event, PAD_ADD), //SO_KEY_RELEASE_EVENT (event, Q) Motores o engines Motores o engines Son objetos que conectan campos (fields) Principalmente se usan para animar la escena Entradas: campos (SoField) Salidas: objeto especial (SoEngineOutput) Tipos Aritméticos SoCalculator (lento) Animación Eventos temporales SoTimeCounter Entrada 1 Eventos no temporales Entrada 2 SoCounter Salida 1 Usado para manipular arrays SoSelectOne Entrada n Se pueden concatenar motores a otros motores Los campos pueden ir directamente conectados sin motores connectfrom (otro campo o un salida de un motor)

Ejemplo Rutas SoCalculator *calc=new SoCalculator; SoTranslation *t1=new SoTranslation; SoTranslation *t2=new SoTranslation; //Conectamos dos traslaciones. A una de ellas le //anulamos la coordenada y calc->a.connectfrom(&t1-> translation); t2->translation.connectfrom(&calc->oa); calc->expression.set1value(0,sbstring("oa[0]=a[0]")); calc->expression.set1value(1,sbstring("oa[1]=0")); calc->expression.set1value(2,sbstring("oa[2]=a[2]")); Objeto SoPath Indican caminos dentro del grafo de escena Es una cadena de nodos donde cada eslabón es hijo del anterior Utilidad Almacenan subgrafos de la escena Todas las acciones que se aplican a un nodo pueden aplicarse a un Path Acciones Ejemplo Clase padre SoAction Son operaciones que se realizan sobre una escena, nodo o ruta. Ejemplos Renderizado SoGlRenderAction Escritura en un fichero SoWriteAction Cálculo de Bounding Boxes SoGetBoundingBoxAction Búsquedas de nodos SoSearchAction Cálculo de la matriz de transformación SoGetMatrixAction SoSeparator * root = new SoSeparator; root->ref(); SoPerspectiveCamera * pcam = new SoPerspectiveCamera; root->addchild(pcam); SoEventCallback * ecb = new SoEventCallback; ecb->addeventcallback(somousebuttonevent::getclasstypeid(), event_cb, viewer); root->addchild(ecb); //Componente de alto nivel utilizado para pintar viewer->setscenegraph( root ); pcam->viewall( root, viewer->getviewportregion() ); ------------------------------------------------------------------------------------- // attempting raypick in the event_cb() callback method SoRayPickAction rp( viewer->getviewportregion() ); rp.setpoint(mouseevent->getposition()); rp.apply(viewer->getscenegraph()); rp. getpickedpoint().getpath(); //SoPickedPoint

Ejemplo Sensores SbMatrix gettrans(sonode *node, SoGroup *root) SoSearchAction *sa=new SoSearchAction; sa->setnode(node); sa->apply(root); path=searchaction->getpath(); assert(path); Derivan de la clase SoSensor Son mecanismos de OI para planificar tareas Existen dos colas de tareas Delay queue: las tareas de esta cola se activan cuando la CPU tiene tiempo libre Timer queue: las tareas de esta cola se activan por un evento temporal Las tareas se activan mediante callbacks SoGetMatrixAction * gma =new SoGetMatrixAction (SbViewportRegion()); gma->apply(path); return gma->getmatrix() Ejemplo Ejemplo viewer->setautoredraw(false); SoIdleSensor* rendertimer = new SoIdleSensor(render,0L); rendertimer->setinterval(render_step); rendertimer->schedule(); ------------------------------------------------------------------------- --------------------- void render (void *, SoSensor *) viewer->render(); viewer->setautoredraw(false); SoTimerSensor* rendertimer = new SoTimerSensor(render,NULL); rendertimer->setinterval(render_step); rendertimer->schedule(); --------------------------------------------------------------------------------- ------------- void render (void *, SoSensor *) viewer->render();

Componentes de alto nivel Componentes de alto nivel Es propia del gestor de ventanas que utilizamos: SoWin, SoXt, SoGtk, SoQt Nos ofrecen Funciones de inicialización y gestión de ventanas Tratamiento de eventos Áreas para renderizar escenas Componentes para cambiar la escena (editores de materiales ) Capturan los eventos del gestor de ventanas So???::mainLoop() Los utilizan ellos mismos Los pasan a la base de datos Inicialización del gestor de ventanas y la base de datos So???::init Tipos de objetos Componentes Áreas de renderizado SoWinRenderArea Visualizadores SoWinViewer» SoWinExaminerViewer,SoWinPlaneViewer Otros componentes Dispositivos Captura de eventos Teclado Ratón Ejemplo #include <Inventor/Win/SoWin.h> #include <Inventor/Win/viewers/SoWinExaminerViewer.h> #include <Inventor/nodes/SoBaseColor.h> #include <Inventor/nodes/SoCone.h> #include <Inventor/nodes/SoSeparator.h> int main(int argc, char ** argv) HWND mainwin = SoWin::init(argc, argv, argv[0]); SoSeparator * root = new SoSeparator; root->ref(); root->addchild(new SoCone); SoWinExaminerViewer * eviewer = new SoWinExaminerViewer(mainwin); eviewer->setscenegraph(root); eviewer->show(); eviewer->settransparencytype(soglrenderaction::sorted_object_blend); SoWin::show(mainwin); SoWin::mainLoop(); // Clean up resources. delete eviewer; root->unref(); Relación entre OpenInventor y OpenGl OI permite construir aplicaciones con un alto nivel de abstracción Si no queremos usar los componentes de alto nivel podemos usar OpenGl para el renderizado y el tratamiento de los eventos Nos permite combinar las ventajas de ambos Ejemplo: Pintar un grafo de escena y pasar un filtro al framebuffer. Aumenta la complejidad return 0;

Implementaciones de OI OI de SGI Gratuito Disponible Irix Linux Coin3d Gratuito con propósitos no comerciales Versión profesional con librerías adicionales Disponible Linux Windows Mac OS X Como utilizar Coin3d con Visual Stutio Instalar las librerias Coin3D Simage (texturas) SoWin o SoQt (según el gestor de ventanas que vayamos a utilizar) Crear una variable de entorno con la dirección de la librería $(COIN3DDIR) C:\COIN3D\ Introducir en el path donde están las dlls $(PATH) C:\COIN3D\BIN Volver a arrancar el sistema Como utilizar Coin3d con Visual Stutio Crear un proyecto Aplicación de consola Vacía Configurar el proyecto C/C++ Preprocessor definition Introducir las variables de entorno de Coin» SIMAGE_DLL, COIN_DLL, SOWIN_DLL» SIMAGE_NOT_DLL, COIN_NOT_DLL, SOWIN_NOT_DLL Preprocessor -> Additional Include Files $(COIN3DDIR)\Include Link Object Library Modules $(COIN3DDIR)\lib\SoWin1.lib $(COIN_DIR)\lib\simage1.lib $(COIN3DDIR)\lib\Coin3.lib Como utilizar Coin3D con gcc Instalación Descargar librerías (Simage, coin, SoXt) Recompilarlos en el orden anterior tar xvfz nombre_paquete-x.y.z.tar.gz cd nombre_paquete-x.y.z./configure make make install (como root) Utilizar los comandos coin-config y soxt-config para compilar y enlazar soxt-config --build nombre_programa fich1.cpp fichn.cpp Para obtener más información sobre estos programas utiliza --help

Índice Eon Studio Introducción Paquetes Componentes Arquitectura e interfaz Introducción Paquetes Toolkit 3D Interfaz gráfico Funciona solo bajo Microsoft Windows Toolkit propietaria Extensible Da soporte para algún dispositivo I/O Cuevas Trackers Funciona sobre DirectX o OpenGl No es una herramienta de modelado Importa modelos (Okino) Dota a los modelos de comportamiento Eon Studio Importa modelos Utiliza Okino Creación de modelos interactivos No se necesita experiencia en programación Eon Inmersive Extensión de Eon Studio No incluido en el paquete básico Permite utilizar Eon con dispositivos RV Eon Viewer Permite visualizar proyectos Eon Gratuito

Paquetes Componentes Eon Raptor Plugin para 3D Studio SDK Librerías de C++ Totalmente integrado con Visual C++ Contiene nuevos wizards Basado en tecnología COM Permite extender los nodos y módulos de Eon Studio Permite integrar modelos Eon en nuestras aplicaciones Eon Turbo Permite publicar en la web modelos Eon Eon Xtra Plugin para explorer Permite visualizar modelos Eon Árbol de simulación Contiene todos los objetos que participan en la simulación (nodos) Scene graph Nodos Todos los objetos Eon son nodos que se cuelgan del árbol. Tipos Grupo Render Agentes Sensores Modelos de movimiento Scrips Componentes Componentes Campos Variables contenidas en los nodos Tipos de datos Números Cadenas Arrays Booleanos Punteros Vectores geométricos (traslaciones, rotaciones ) Tiempo Nodos Clases de campo Field: Campos internos de un nodo EventIn: Campos que recibe un nodo como eventos de entrada EventOut: Campos que recibe un nodo como eventos de salida ExposedField: Campos que pueden ser tratados tanto como eventos de entrada como eventos de salida. Conexiones y rutas Se define el comportamiento de los nodos conectando sus campos Prototipos Encapsulan nodos y sus conexiones internas

Arquitectura Interfaz