Lenguajes de programación para la animación by dannyasd

Universidad de Navojoa

Trabajo de investigación, presentado para el cumplimiento de la materia de Animación, que lleva como título, “Lenguajes de Programación para la animación”.

Maestro: Ing. Misael Martínez Por: Ricardo Daniel Carrada Peña

CONTENIDO Autores: .................................................................................................................................................................................... 3 Resumen. ................................................................................................................................................................................. 3 Palabras Clave ........................................................................................................................................................................ 4 Introducción. ............................................................................................................................................................................ 4 OpenGL .................................................................................................................................................................................... 7 Historia .................................................................................................................................................................................. 7 Ventajas de OpenGL .......................................................................................................................................................... 8 Acciones de OpenGL ......................................................................................................................................................... 9 Arquitectura gráfica ............................................................................................................................................................. 9 Framebuffer ................................................................................................................................................................... 10 Sintaxis de OpenGL...................................................................................................................................................... 10 Flujo de renderización de OpenGL ............................................................................................................................ 10 Bibliotecas relacionadas con OpenGL ........................................................................................................................... 11 OpenGL Utility Library (GLU) ...................................................................................................................................... 11 GLX y WGL .................................................................................................................................................................... 12 AUX ................................................................................................................................................................................. 12 OpenGL Utility Toolkit (GLUT) .................................................................................................................................... 12 Sintaxis de los comandos de OpenGL .......................................................................................................................... 13 Conclusión ............................................................................................................................................................................. 16 Bibliografía ............................................................................................................................................................................... 16

AUTORES: Ricardo Daniel Carrada Pe帽a Portafolio: http://dannyasd.com Animaci贸n. Universidad de Navojoa. Km13 carretera Navojoa Huatabampo cp. 85800 Email: 1100251@unav.edu.mx

RESUMEN.

En esta investigación, veremos características de la programación en modelado 3d. En el transcurso de la materia de Animación del plan de curso 2011 de la Universidad de Navojoa, vimos a fondo lo que es el modelado en 3d, utilizando la herramienta de nombre Maya de la suite Autodesk, utilizamos la versión de estudiante, en el semestre en curso realizamos modelados básicos con polígonos y poco a poco fuimos aprendiendo más de las herramientas que ofrece este producto, después de aprender a modelar, pasamos a las texturas, creamos Uvs, aprendimos a que todo nuestro modelo debe de tener un orden ya que al generar Uvs podríamos tener problemas con las texturas. Posteriormente aprendimos a insertar Joints, esto significa que le pusimos huesos a nuestro modelado, ya que esto hará que simule la forma de huesos en nuestro modelado, vimos en esta sección que debemos bloquear permisos para rotación o traslación de algunos de los huesos ya que en la vida real, por ejemplo nuestra cabeza no puede girar completamente. Ya que concluimos con esta sección nos dedicamos a unir los huesos con el modelado y a generar pesos, para simular la gravedad de nuestro modelado. Para finalizar realizamos un render de nuestro modelo y nuestro producto Final lo podemos ver en mi portafolio dannyasd.com . Para finalizar con este aprendizaje realizaremos una investigación de como programar nuestro modelado o nuestro mundo ya que lo tenemos completado.

PALABRAS CLAVE Gráficos 3D interactivos, simulación, jerarquía de escena, modelado, composición de escenas, Maya.

INTRODUCCIÓN.

El uso de las aplicaciones para dibujar gráficos 3D en tiempo real se ha estandarizado en áreas tan diversas como los juegos interactivos, películas y simulaciones, hasta la 4

visualización de datos para usos científicos, médicos y comerciales. En este sentido, veremos OpenGL y como constituye una de las interfaces de programación más recomendadas en este campo por su excelente estabilidad y rendimiento. Este libro es muy recomendado ya que se familiarizará con los elementos básicos de la programación de gráficos 3D con OpenGL, aprendiendo a construir un programa que use OpenGL, establecer el entorno de interpretación 3D y a crear objetos básicos así como a aplicarles luces y sombras y mucho más. El lector encontrará además toda la información específica que necesite dependiendo del sistema operativo con el que trabaje, y a medida que avance en el uso de esta API gráfica irá profundizando en el conocimiento de sus opciones avanzadas y los distintos efectos especiales que permite. (shreiner, 2009). También veremos algunas definiciones de otros programas para modelado en 3d. A pesar de haber muchas aplicaciones de modelado y animación 3D, algunas de las que se han ganado la mayor popularidad son: 

3D Studio Max: Fue originalmente escrito por Kinetix (una división de Autodesk) como el sucesor de 3D Studio para DOS. Más tarde Kinetix se fusionaría con la última adquisición de Autodesk, Discreet Logic. Es el líder en el desarrollo 3D de la industria del videojuego y es muy utilizado a nivel amateur.



Blender: Programa de creación de contenido 3D que abarca desde el modelado y animación hasta la composición y renderización de complejas escenas en 3D. Es software libre, y cuenta con características como soporte para programación bajo Python con una amplia gama de script en constante desarrollo, posee un engine robusto para la programación de juegos, un motor de render propio y una comunidad de usuarios totalmente abierta y dispuesta a colaborar.



Lightwave 3D: Fue originalmente desarrollado por Amiga Computers a principios de la década de los 90. Más tarde evolucionó en un avanzado paquete gráfico y animación 3D. Actualmente disponible para Windows, Mac OS y Mac OS X. El

programa consiste en dos componentes: el modelador y el editor de escena. Es utilizado en multitud de productoras de efectos visuales como Digital Domain. 

Maya: Es quizá el software más popular en la industria, por lo menos hasta 2003. Es utilizado por multitud de importantes estudios de efectos visuales en combinación con RenderMan, el motor de render foto realista de Pixar.



Softimage XSI: El contrincante más grande de Maya. En 1987, Softimage Inc., una compañía situada en Montreal, escribió Softimage|3D, que se convirtió rápidamente en el programa de 3D más popular de ese período. En 1994, Microsoft compró Softimage Inc. y comenzaron a reescribir SoftImage|3D para Windows NT. El resultado se llamó Softimage|XSI. En 1998 Microsoft vendió Softimage a Avid.



Caligari trueSpace: una aplicación 3D integrada, con una interfaz muy intuitiva. Una característica distintiva de esta aplicación es que todas las fases de creación de gráficos 3D son realizadas dentro de un único programa. No es tan avanzado como los paquetes líderes, pero provee características como simulación de fenómenos físicos (viento, gravedad, colisiones entre cuerpos).



Cinema4d: Motor de render rápido, cálculo de radiosidad.



formZ: Ofrece manipulación topológica de las geometrías.



Moray: Modelador para POV-Ray.



POV-Ray: Un avanzado programa gratuito de Raytracing. Usa su propio lenguaje de descripción de escena, con características como macros, bucles y declaraciones condicionales. Es completamente gratuito aunque no fue lanzado bajo GPL. No incluye modelador.



RealSoft3D: Modelador 3D para Linux y Windows. Incluye rénder.



Rhinoceros 3D: Un potente modelador bajo NURBS.



SketchUp: Programa de modelado 3D adquirido por Google. Existe una versión gratuita y una versión SketchupPro. La razón por la que Google adquirió SketchUp

es para mejorar los plugins del programa de mapas en 3D Google Earth, Trimble adquirió Sketchup de Google en el 2012. (http://es.wikipedia.org/, 2014)

OPENGL ¿Qué es OpenGL? OpenGL (Open Graphics Library) es una especificación estándar que define una API multilenguaje y multiplataforma para escribir aplicaciones que produzcan gráficos 2D y 3D. La especificación es un documento que describe un conjunto de funciones y el comportamiento exacto que deben tener. Partiendo de ella, los fabricantes de hardware crean implementaciones, que son bibliotecas de funciones que se ajustan a los requisitos de la especificación, utilizando la aceleración por hardware cuando es posible. Existen distintas versiones que representan conjuntos de funcionalidades (OpenGL 1.2, OpenGL ES...) (shreiner, 2009)

HISTORIA Antes de la aparición a OpenGL, muchos fabricantes tenían diferentes bibliotecas gráficas, esto hacia que hubiera que tratar con interfaces muy diferentes y escribir drivers específicos para cada tipo de hardware, resultando muy costoso. Para solventar esto, se subcontrataban equipos de programadores para agilizar el desarrollo, los cuales tenían que implementar manualmente el código necesario para que el programa pudiera trabajar con cada plataforma, sistema operativo y hardware diferente. Dado que cada equipo trabajaba por separado en sus interfaces, se producía mucho código redundante. También producía que la potabilidad de aplicaciones de una plataforma hardware a otra consumiera demasiado tiempo y entrañara dificultad. Al principio de los años 1990 SGI era un grupo de referencia en gráficos 3D para estaciones de trabajo. Suya era la API IRIS GL, considerada puntera en el campo y 7

estándar de facto, llegando a eclipsar a PHIGS, basada en estándares abiertos. IRIS GL se consideraba más fácil de usar y, lo más importante, soportaba rende rizado en modo inmediato. Además, PHIGS, aparte de su mayor dificultad, fue considerada inferior a IRIS GL respecto a funcionalidad y capacidad. (Richard S. Wright, 2004) VENTAJAS DE OPENGL Es independiente del Hardware y del Sistema Operativo (hay versiones de OpenGL para Windows, Linux, Mac, y se puede encontrar hardware que lo soporte hasta en dispositivos móviles (iOS, Android...). Existe hardware dedicado que lo acelera considerablemente, permitiendo pintar escenas complejas a tiempo real (las últimas tarjetas pueden renderizar del orden de Millones de polígonos por segundo) Hay implementaciones para cualquier lenguaje (C, Python, Java, JavaScript, C#...) Al ser de bajo nivel da libertad para que el programador pueda construir encima lo que necesite.

La informática gráfica es la parte de la informática que se encarga de la representación de gráficas en el ordenador y se ha convertido en el mundo de la computación en un recurso habitual para la comunicación entre los ordenadores y los usuarios. En la actualidad las implicaciones son múltiples con otros sectores y su importancia es extrema. Se encarga del almacenamiento, creación y visualización de imágenes en el ordenador. Las imágenes reales o con efectos realistas se consiguen aproximando al máximo la representación gráfica que se genera en la pantalla a las imágenes que percibe el ser humano con la vista. Para dar realismo a las imágenes se emplean técnicas de luz, colores, texturas, transparencias, brillos, etc. OpenGL fue la primera librería gráfica que abordo el uso eficiente de esos recursos, así como la estandarización de los procedimientos de la generación de gráficos.

Actualmente es un estándar sobre gráficos por computadora, uno de los más prestigiosos y utilizados del mundo. (Bernabé.) ACCIONES DE OPENGL Pintar figuras geométricas básicas (puntos, líneas y triángulos). Efectuar transformaciones sobre los vértices (translaciones, rotaciones y escalados). Definir proyección para convertir de coordenadas 3D a la pantalla 2D. Tener en cuenta oclusiones en el pintado de primitivas. Texturizar las figuras en base a una imagen y a coordenadas de textura para cada vértice. Definir el algoritmo de pintado del pixel (shaders) Definir el algoritmo de transformación del vértice. Definir el algoritmo de teselacion de una malla. Todo esto se puede simplificar a: OpenGL sirve para pintar triángulos en pantalla de forma eficiente. ARQUITECTURA GRÁFICA

OpenGL implementa una arquitectura cliente servidor, donde un programa (el cliente) solicita comandos y dichos comandos son interpretados y procesados por el sistema OpenGL (el servidor). No es necesario que el servidor se sitúe en el mismo ordenador que el cliente, permitiendo a la especificación OpenGL ser “transparente a la red”. Un mismo servidor puede mantener una serie de contextos OpenGL, representando cada uno de ellos el encapsulamiento de un estado OpenGL. Un cliente selecciona el contexto al que se desea conectar para solicitar las operaciones (y el 9

comportamiento ante la solicitud de comandos sin estar conectado a un contexto queda sin definir).

FRAMEBUFFER ● Región de memoria donde se renderiza la escena. ●Se encuentra en la VRAM por lo que no es accesible desde nuestro código. ●El tamaño en memoria viene dado por la siguiente fórmula: Ancho pantalla x Alto pantalla x Número de canales x bytes por muestra = Tamaño total en memoria. SINTAXIS DE OPENGL //Función que recibe un ENUM propio de OpenGL glBegin( GL_POINTS ); //Función que recibe 3 valores del tipo float

glColor3f(1.0, 1.0, 1.0); //Función que recibe 3 valores de tipo float desde un array glVertex3fv( punto ); //Función sin parámetros glEnd(); FLUJO DE RENDERIZACIÓN DE OPENGL

La mayoría de las implementaciones de OpenGL implementan un orden de operaciones idéntico, una serie de etapas de procesamiento denominado el flujo de renderización de OpenGL (OpenGL rendering pipeline). El flujo está representado en la Ilustración 2.1, y aunque es necesario resaltar que no es una definición estricta ni obligatoria, proporciona indicaciones bastante fiables sobre el orden de las operaciones en OpenGL. (Bernabé.)

BIBLIOTECAS RELACIONADAS CON OPENGL OpenGL contiene un conjunto de poderosos pero primitivos comandos que efectúan operaciones a muy bajo nivel. Además, acciones como la apertura de una ventana en el sistema grafico u otras similares no entran en el ámbito de OpenGL. Por ello es muy habitual contar con el apoyo de algunas bibliotecas de funciones ajenas a OpenGL pero muy relacionadas con ella. Las más populares se describen a continuación: OPENGL UTILITY LIBRARY (GLU)

Contiene bastantes rutinas que usan OpenGL a bajo nivel para realizar tareas como transformaciones de matrices para tener una orientación específica, subdivisión de polígonos, etc. Son funciones con un nivel de abstracción por encima de OpenGL para facilitar la labor de programación de aplicaciones. Esta biblioteca suele estar incluida en las implementaciones OpenGL y sus métodos son fácilmente reconocibles porque comienzan por el prefijo glu. GLX Y WGL GLX da soporte para maquinas que utilicen X Windows System y permite realizar todos los procesos gráficos relacionados con las ventanas de aplicación. WGL es el equivalente para sistemas Microsoft. AUX La biblioteca de funciones AUX fue desarrollada en la etapa inicial de desarrollo de OpenGL por SGI para server de apoyo a la creación de pequeños programas de demostración. Actualmente está declarada obsoleta y ya no está ni soportada ni actualizada. El desarrollo de aplicaciones utilizando esta biblioteca está es aconsejado, debiéndose utilizar GLUT en su lugar.

OPENGL UTILITY TOOLKIT (GLUT) Es un sistema de ventanas, escrito por Mark Kilgard, independiente del sistema usado. GLUT ofrece una interfaz común para múltiples plataformas para el manejo de ventanas, buffers, renderización de texto, entrada por teclado y menús, permitiendo a los desarrolladores utilizar un interface común para el sistema de ventanas independiente de la plataforma. Además, debido a su sencillez, tiene una suave curva de aprendizaje. GLUT es actualmente soportado por varios lenguajes, en especial

ANSI C y FORTRAN.

SINTAXIS DE LOS COMANDOS DE OPENGL Como habrá observado desde el sencillo programa en la sección anterior, los comandos de OpenGL utilizan el prefijo gl y una letra inicial mayúscula para cada palabra que compone el nombre del comando (recordar glClearColor () , por ejemplo). Del mismo modo, las constantes OpenGL definido comienzan con GL_, use letras mayúsculas, y el uso de subrayado para separar palabras (como GL_COLOR_BUFFER_BIT). También puede haber notado algunas letras aparentemente extraños adjuntas a algunos nombres de comandos (por ejemplo, el 3f en glColor3f () y glVertex3f () ). Es cierto que el color de la parte del nombre del comando glColor3f () es suficiente para definir el comando como el que establece el color actual. Sin embargo, más de uno de esos comandos se ha definido de manera que se pueden utilizar diferentes tipos de argumentos. En particular, la 3 parte del sufijo indica que se dan tres argumentos; otra versión del color comando toma cuatro argumentos. El f parte del sufijo indica los números de coma flotante que los argumentos se. Tener diferentes formatos permite OpenGL para aceptar los datos del usuario en su propio formato de datos.

Algunos comandos OpenGL aceptan hasta 8 tipos de datos diferentes para sus argumentos. Las letras utilizadas como sufijos para especificar estos tipos de datos para ISO C implementaciones de OpenGL se muestran en la Tabla 1.1, junto con las definiciones de tipo OpenGL correspondientes. La aplicación particular de OpenGL que está utilizando podría no seguir este esquema exactamente; una implementación en C ++ o Ada, por ejemplo, no sería necesario. Tabla 1-1: Comando sufijos y de argumentos de tipos de datos 13

Sufijo

Tipo de datos

Típico Correspondiente tipo

Tipo OpenGL

C-Idioma

Definición

8-bit número entero

signed char

GLbyte

Entero de 16 bits

corto

GLshort

Entero de 32 bits

int o largo

Glint, GLsizei

32-bit de punto

flotador

GLfloat, GLclampf

doble

GLdouble, GLclampd

unsigned char

GLubyte, GLboolean

unsigned short

GLushort

unsigned int o unsigned long

GLuint, GLenum,

flotante d

64-bit de punto flotante

8 bits entero sin signo

nosotros

Entero de 16 bits sin signo

Entero de 32 bits sin signo

GLbitfield

Así, los dos comandos glVertex2i (1, 3); glVertex2f (1.0, 3.0); Son equivalentes, excepto que la primera especifica las coordenadas del vértice como enteros de 32 bits, y el segundo de ellos especifica como números de punto flotante de precisión simple.

Las implementaciones de OpenGL tienen libertad de acción en la selección de tipo de datos C a utilizar para representar tipos de datos de OpenGL. Si utiliza resueltamente los tipos de datos de OpenGL definido a través de su aplicación, se evitará tipos no coincidentes al portar su código entre diferentes implementaciones. Algunos comandos de OpenGL pueden tomar una última carta v , lo que indica que el comando toma un puntero a un vector (o matriz) de valores en lugar de una serie de argumentos individuales. Muchos comandos tienen ambas versiones vectoriales y no vectorial, pero algunos comandos sólo aceptan argumentos individuales y otros requieren que al menos algunos de los argumentos especificarse como un vector. Las siguientes líneas muestran cómo se puede utilizar un vector y una versión no vectorial de la orden que establece el color actual: glColor3f (1.0, 0.0, 0.0); GLfloat color_array [] = {1.0, 0.0, 0.0}; glColor3fv (color_array); Finalmente, OpenGL define el GLvoid typedef. Esta es la más utilizada por los comandos de OpenGL que aceptan punteros a matrices de valores.

En el resto de esta guía (excepto en ejemplos de código reales), los comandos de OpenGL se conocen sólo por sus nombres de base, y un asterisco se incluye para indicar que puede haber más que el nombre del comando. Por ejemplo, glColor * () significa todas las variantes del comando se utiliza para establecer el color actual. Si queremos hacer un punto específico acerca de una versión de un comando en particular, incluimos el sufijo necesario definir esa versión. Por ejemplo, glVertex * v () se refiere a todas las versiones del vector del comando que se utiliza para especificar vértices. (http://www.glprogramming.com/red/chapter02.html, 2013)

Conclusión

Para concluir esta investigación como vimos es un mundo de infinidad de opciones que tenemos, apenas vimos una pincelada de lo que es la programación para animación, y para modelado en 3d, esto nos abrirá un panorama en la siguiente materia veremos, la materia Desarrollo para Sistemas para el Entretenimiento, en la cual viendo lo que expuso nuestro compañero Daniel Lozano, veremos programación para crear un juego ya sea para mobiles o pc utilizando diversas herramientas, unas de las herramienta que uso nuestro compañero fue Unreal Engine. En un Futuro utilizare mi modelo que realice en la materia de animación.

BIBLIOGRAFÍA Bernabé., R. B. (s.f.). gsii.usal.es. Obtenido de http://gsii.usal.es/~igrafica/descargas/temas/Tema02.pdf http://es.wikipedia.org/. (5 de 10 de 2014). wikipedia.org. Obtenido de http://es.wikipedia.org/wiki/Software_de_gr%C3%A1ficos_3D http://www.glprogramming.com/red/chapter02.html. (08 de 11 de 2013). http://www.glprogramming.com/red/chapter02.html. Obtenido de http://www.glprogramming.com/red/chapter02.html: http://www.glprogramming.com/red/chapter02.html Richard S. Wright, B. L. (2004). OPENGL. España: ANAYA.

shreiner, D. (2009). OpenGL Programming Guide. United States of America: Person Education,Inc.