Creacion de Animaciones en Tiempo Real C

REPORTE FINAL DE RESIDENCIAS
Nombre del Proyecto: PROTOCOLO PARA LA CREACION DE ANIMACIONES EN

TIEMPO REAL.
Empresa: Instituto Tecnológico de Cd. Madero.
Lugar: División de Estudios de Posgrado e Investigación.
Dirección: Juventino Rosas y Jesús Urueta. Col. Los Mangos C.P. 89440 Cd. Madero,
Tamaulipas, México.
Teléfono: 215-85-44.
Nombre del Jefe de Unidad Académica: MP. Ma. Yolanda Chávez Cinco
Nombre del Asesor Externo: Dra. Ma. Lucila Morales Rodríguez
Perfil: Computación
Puesto: Profesor Investigador
Correo Electrónico: lmoralesrdz@gmail.com
Periodo de Realización de Residencia: Febrero-Julio 2010
Inicio: 23 de Febrero del 2010 Fin: 01 de Julio del 2010
Horario de trabajo: Lunes a Viernes de 8:00 – 16:00 hrs.
Horas totales: 640 horas
Participantes:
Nombre del alumno: Palomera Hervert Iván de Jesús Núm. Control: 04070694
Carrera: Ingeniería en Sistemas Computacionales
Correo Electrónico: ing.ivan_palomera@hotmail.com
Nombre del alumno: Hernández Ruiz Marco Polo Núm. Control: 04070789
Carrera: Ingeniería en Sistemas Computacionales
Correo Electrónico: markhr_06@hotmail.com
NOTA: Este proyecto está perfilado para titulación por tesis (Opción I).
INDICE
Capítulo I. Introducción................................................................................................................. 5
1.1 Instituto Tecnológico de Ciudad Madero............................................................................ 5
1.1.1. Antecedentes............................................................................................................. 5
1.1.2. Maestría en Ciencias de la Computación .................................................................. 5
1.2 Información del Proyecto de Residencias ........................................................................... 6
1.2.1. Antecedentes .............................................................................................................. 6
1.2.2. Justificación ................................................................................................................. 6
1.3. OBJETIVOS .......................................................................................................................... 7
1.3.1. Objetivo General ......................................................................................................... 7
1.3.2. Objetivos Específicos................................................................................................... 7
1.4. Caracterización del Área .................................................................................................... 7
1.5. Problemas a Resolver......................................................................................................... 8
1.6. Alcances y Limitaciones...................................................................................................... 8
1.6.1. Alcances....................................................................................................................... 8
1.6.2. Limitaciones ................................................................................................................ 8
Capítulo II. Marco Teórico............................................................................................................. 9

2.1. Introducción ....................................................................................................................... 9
2.2. Motor de Juego Panda 3D.................................................................................................. 9
2.3. Lenguaje de Programación................................................................................................. 9
2.3.1. Python ....................................................................................................................... 10
2.4. Animación 3D ................................................................................................................... 10
2.4.1. Sistema de coordenas ............................................................................................... 10
2.4.2. Ángulos de Euler........................................................................................................ 11
2.4.3. Definición .................................................................................................................. 11
2.5. Modelado 3D.................................................................................................................... 13
2.5.1. Herramientas de modelado ...................................................................................... 13
2.6. Personajes Virtuales......................................................................................................... 13
2.6.1. Mundos Virtuales ...................................................................................................... 14
2.6.2. Mundos Virtuales en la Educación ............................................................................ 14
2.7. Actores en Panda3D ........................................................................................................ 15
2.8. Animaciones ..................................................................................................................... 15
2.8.1 Animación Básica........................................................................................................ 15
2.8.2 Animación de Medio Cuerpo ..................................................................................... 16
2.9. Intervalos.......................................................................................................................... 16
2.9.1. Intervalos de Actores ................................................................................................ 17
2.9.2. Uso de Intervalos....................................................................................................... 17
Capítulo III. Descripción del Proyecto....................................................................................... 19

3.1. Descripción General del Proyecto ................................................................................. 19
3.2. Metodología del Proyecto .............................................................................................. 19
3.3. Análisis de los Requerimientos...................................................................................... 22
3.3.1. Infraestructura Física................................................................................................ 22
3.3.2. Software .................................................................................................................... 22
3.3.3. Infraestructura Humana........................................................................................... 22
Capítulo IV. Desarrollo del Proyecto ........................................................................................ 23

4.1. Descripción de las actividades realizadas ........................................................................ 23
4.2. Procedimiento del desarrollo de residencias................................................................... 24
4.2.1. Instalación del Software............................................................................................ 24
4.2.2. Geometría Básica en Panda3D .................................................................................. 29
4.2.3. Formato de Archivo Primario de Panda. ................................................................... 29
4.2.4. Manipulación de Ambiente o Escenario ................................................................... 30
4.2.5. Movimiento de la cámara ......................................................................................... 31
4.2.6. Carga y Manipulación de Actores.............................................................................. 34
4.2.7. Manejo del Teclado y Mouse .................................................................................... 36
4.2.8. Animación de Actores ............................................................................................... 38
4.2.9. Manipulación de Actores .......................................................................................... 39
4.2.3. Manipulación de Todas las Partes del Cuerpo ................................................. 49
Capítulo V. Resultados y Conclusiones..................................................................................... 69

5.1. Resultados ........................................................................................................................ 69
5.2. Conclusiones..................................................................................................................... 69
Bibliografía .................................................................................................................................. 70
Capítulo I. Introducción
1.1 Instituto Tecnológico de Ciudad Madero
1.1.1. Antecedentes
La historia del Instituto Tecnológico de Cd. Madero inicia con la perseverante labor del
Ing. Luis Hidalgo y Castro quien concibió la idea de fundar una casa de estudios
técnicos que permitiera a los jóvenes de la región recibir una formación profesional del
más alto nivel sin tener que emigrar a otras ciudades.
Tras de vencer múltiples obstáculos de carácter político, económico y social, y con la
cooperación exclusiva de la gente de escasos recursos de esta ciudad, se hizo posible
reunir inicialmente la cantidad de 25 mil pesos, que fue el principio virtual del
Tecnológico de Cd. Madero. Posteriormente, gracias a la colaboración de las
Secciones Petroleras de la Zona Norte se logró reunir el primer millón de pesos del
patronato en 1950.
En el mes de septiembre de ese mismo año; El entonces Presidente de la República,
Lic. Miguel Alemán Valdés, autorizó el convenio tripartita en el que se establecería la
cooperación de PEMEX, la Secretaria de Educación Pública y el Patronato, cada uno
con un millón de pesos, para la construcción de nuestro instituto, bajo la supervisión
del Instituto Politécnico Nacional.
Después de 4 años, las clases dieron inicio el día 2 de septiembre de 1954 con 511
alumnos uniformados de guinda y blanco. En justo reconocimiento a su labor, la
superioridad otorgo el cargo de director al Sr. Ingeniero Luis Hidalgo y Castro.
Los cursos a nivel licenciatura iniciaron en 1956 con las carreras de Ingeniería
Eléctrica, Mecánica y Química. En 1961 se procedió a la apertura de Ingeniería
Industrial y en 1975 se iniciaron las carreras de Geología y Geofísica.
A mediados de la década de los 80's se abrieron las carreras de Ingeniería Electrónica
e Ingeniería en Sistemas Computacionales. La más reciente carrera, Lic. en
Informática dio inicio en septiembre de 1995.
En el año 2000, se inició un programa propio denominado originalmente Maestría en
Computación. Actualmente cambió de nombre a Maestría en Ciencias en Ciencias de
la Computación. Este programa cuenta con una sola línea de investigación de
optimización inteligente, donde se profundiza en problemas que por su complejidad,
requieren de encontrar soluciones óptimas, mediante los nuevos métodos de
computación inteligente.
1.1.2. Maestría en Ciencias de la Computación
1.1.2.1. MISIÓN
La Maestría en Ciencias en Ciencias de la Computación es un programa que depende

de la División de Estudios de Posgrado e Investigación. Orienta sus capacidades y
esfuerzos a formar especialistas en Ciencias de la Computación con un alto nivel
científico y tecnológico que sirva de sustento al sector académico, de investigación,
5
productivo y social del país; con capacidad de realizar investigación básica y aplicada,
así como desarrollos tecnológicos de alto nivel con impacto nacional e internacional en
al campo de la computación inteligente; sustenta los conocimientos científicos y
tecnológicos para atender la problemática del sector productivo nacional en las áreas
de Visión Computacional y Bases de datos distribuidas; forma grupos de investigación
y desarrollo que contribuyen a satisfacer la demanda nacional e impartir cátedra en el
campo de la computación.
1.1.2.2. VISIÓN GENERAL
Que la Maestría en Ciencias en Ciencias de la Computación sea un programa

consolidado perteneciente al Padrón de excelencia del CONACYT, y se caracterice
por el cumplimiento de todos los indicadores de este organismo. Además deberá
establecer convenios con instituciones nacionales e internacionales para el desarrollo
de proyectos.
1.1.2.3. OBJETIVO
Formar especialistas en la Ciencia de la Computación con un alto nivel científico y

tecnológico que sirvan de sustento al sector académico, de investigación y productivo
del país.
1.2 Información del Proyecto de Residencias
1.2.1. Antecedentes
Actualmente en la Maestría en Ciencias en Ciencias de la Computación se está

tratando de desarrollar una línea de investigación enfocada al desarrollo de formas de
interacción mediadas por ordenador más naturales a través del uso de personajes
virtuales. Esto con la finalidad de construir de herramientas de simulación para fines
ludo-educativos y profesionales, que permitan una instrucción más eficaz.
Esta residencia forma parte del proyecto Evaluación y análisis de la interpretación del
comportamiento de personajes virtuales. Para realizar el análisis de éstos personajes
se requiere contar con los modelos 3D que los representen.
1.2.2. Justificación
Esta residencia podrá facilitar el trabajo futuro para los próximos proyectos de
maestría, disminuyendo esfuerzo en el proceso de animación de personajes y
facilitando el aprendizaje.
Así mismo, se identificaran las propiedades y funciones que trabajan con huesos y
Esqueletos para posteriormente crear una biblioteca de funciones con las cuales se
podrán manipular las diferentes partes del cuerpo de los personajes. Con esto
6
buscamos que éstos sean capaces de producir expresiones no verbales y puedan
llegar a generar una sensación de inmersión en un mundo virtual.
1.3. OBJETIVOS
1.3.1. Objetivo General
El objetivo de esta residencia es escribir un protocolo que se enfoque a la

animación de personajes virtuales en Panda3D. En particular, a la
animación de huesos y esqueletos de los personajes.
1.3.2. Objetivos Específicos
Revisión de literatura sobre Animación y Modelado 3D.

Revisión de literatura sobre Animación de Huesos en Panda 3D.
Identificación de Propiedades y funciones que trabajan con Huesos y
Esqueletos.
Desarrollo de prototipo y documentación que ilustre el proceso de
animación de esqueletos.
Desarrollo de biblioteca de funciones que animan las diferentes partes del
cuerpo.
Desarrollo de prototipo que ilustra el funcionamiento de la biblioteca de
funciones.
1.4. Caracterización del Área
Las actividades que se realizan en el área de maestrías en ciencias de la computación

son:
• Orienta sus capacidades y esfuerzos a formar especialistas en Ciencias de la

Computación con un alto nivel científico y tecnológico que sirva de sustento al
sector académico, de investigación, productivo y social del país; con capacidad
de realizar investigación básica y aplicada, así como desarrollos tecnológicos
de alto nivel con impacto nacional e internacional en al campo de la
computación inteligente.
• Sustenta los conocimientos científicos y tecnológicos para atender la

problemática del sector productivo nacional en las áreas de Visión
Computacional y Bases de datos distribuidas.
• Forma grupos de investigación y desarrollo que contribuyen a satisfacer la

demanda nacional e impartir cátedra en el campo de la computación.
7
1.5. Problemas a Resolver
Los problemas que se piensan resolver durante la realización de este proyecto son:
• La creación de un tutorial para facilitar la creación de animaciones en tiempo

real.
• La instalación del software que nos servirá de base para la manipulación de las
diferentes partes de un cuerpo, así como también la instalación del motor de
juego.
• Identificación de propiedades y funciones que trabajan con huesos y

esqueletos.
• Aprender a desarrollar funciones que animen las diferentes partes de un

cuerpo.
1.6. Alcances y Limitaciones
1.6.1. Alcances
El alcance que tendrá este proyecto es la creación de los tutoriales, donde se

implementaran la mayoría de las herramientas disponibles por el software, para la
identificación de propiedades y funciones que trabajan con huesos, así como la
manipulación de las diferentes partes de un cuerpo.
1.6.2. Limitaciones
La principal limitación que tendremos durante el desarrollo de esta práctica es:
• El motor de juego que se utilizara para la importación de los modelos será

Panda 3D.
8
Capítulo II. Marco Teórico
2.1. Introducción
A continuación se trataran algunos conceptos que se manejan dentro de la

programación y del modelado de personajes virtuales. Estos conceptos nos serán de
gran ayuda para poder tener una mejor comprensión acerca de la forma en la que se
pueden desarrollar personajes 3D.
2.2. Motor de Juego Panda 3D
Un motor de Juego es el componente de software central de un video juego que

maneja todos los elementos fundamentales para el desarrollo de este , como lo son
el rendero de gráficos , tareas con el audio, con matemáticas 3d , red e inteligencia
artificial entre otros.
Este término nació a mediados de los 90’s y es relacionado especialmente con los
videos juegos de tipo combate en primera persona , cuyas siglas son FPS ( First-
person shooter). Los precursores de este nuevo modelo de programación de juegos y
aplicaciones 3d fue la compañía productora de video juegos idsoftware, con los
video juegos Quake y Doom para PC.
PANDA 3D es un motor de juego que está formado de una biblioteca de subrutinas

que incluyen también gráficos, audio y otras habilidades relevantes en el desarrollo y
procesamiento de juegos en 3D.
PANDA3D es un sistema 3D enfocado a la creación de videojuegos en PC. Es una
biblioteca de funciones que fueron escritas en C++ que sirven para simplificar
enormemente la creación de videojuegos 3D a través de un lenguaje de programación.
Se pueden usar estas funciones directamente en C++; así mismo puedes programar tu
juego usando Python, el cual es mucho más limpio y cómodo que C++ a la hora de
programar la lógica del juego donde las estructuras de motor suelen ser gestionados
automáticamente (los movimientos de los personajes, respuesta a los controles,
máquinas de estados finitos, etc.). Es software libre y de código abierto. No tiene que
pagar por usarlo.
2.3. Lenguaje de Programación
Un lenguaje que puede ser utilizado para controlar el comportamiento de una máquina,
particularmente una computadora. Consiste en un conjunto de símbolos y reglas
sintácticas y semánticas que definen su estructura y el significado de sus elementos y
expresiones.
9
2.3.1. Python
Python es un lenguaje de programación creado por Guido van Ros sum a principios de
los años 90 cuyo nombre está inspirado en el grupo de cómicos ingleses “Monty
Python”. Es un lenguaje similar a Perl, pero con una sintaxis muy limpia y que favorece
un código legible El tiempo del desarrollado es más importante que el tiempo del
procesamiento del programa; este lenguaje de programación es utilizado por La
Nasa en sus proyectos.
2.4. Animación 3D
Una animación 3d hace referencia a un tipo de animación que simula las tres
dimensiones. Se trata de la descripción de los objetos de un modelo 3d a lo largo del
tiempo. Para que exista animación, esa descripción debe variar en algo con respecto
al tiempo: movimiento de objetos y cámaras, cambio de luces y formas, etc. Puede
tratarse de una animación que se renderiza en tiempo real cuando se está ejecutando,
o una animación que utiliza tres dimensiones pero ya ha sido renderizada
previamente, por lo tanto sólo se trata de un video.
2.4.1. Sistema de coordenas
En el modelado el sistema de coordenadas es de mucha utilidad ya que permiten

definir unívocamente la posición de cualquier punto de un espacio geométrico respecto
de un punto denominado origen.
Cuando realicemos una transformación a un objeto (entre otras operaciones), la

realizaremos respecto a un sistema de coordenadas que nosotros seleccionaremos
(por defecto se hará respecto al sistema de coordenadas de la vista -View-).
Figura 1: Ejemplo del sistema de coordenadas View (el establecido por

defecto), donde los ejes de coordenadas se intercambian en función del visor
que se emplea [3].
eje X: siempre hacia la derecha de la vista

eje Y: siempre apunta hacia arriba
eje Z: siempre apunta hacia el usuario
10
2.4.2. Ángulos de Euler
La orientación de un cuerpo rígido puede especificarse completamente considerando

un sistema de coordenadas fijo a él. Pero, es necesario especificar la relación entre un
sistema de ejes fijo en el espacio y uno fijo en el cuerpo. Podemos construir la
transformación entre estos dos sistemas con tres rotaciones virtuales sucesivas del
cuerpo rígido: de esta manera se introducen los ángulos de Euler. Existen muchas
convenciones para elegir el orden de las rotaciones; sin embargo, en este caso se
usara la convención ”x”, cuyo esquema es el de la Figura 1 y cuya secuencia es la
siguiente: el sistema inicial de ejes xyz se rota alrededor del eje z un ángulo φ; luego,
este nuevo sistema de ejes lo rotamos sobre el nuevo eje x un ángulo θ, para producir
otro conjunto intermedio de ejes; y finalmente, alrededor del nuevo eje z, se rota un
ángulo ψ; todas las rotaciones son en el sentido contrario a las manecillas del reloj.
Los ángulos de Euler φ, θ y ψ especifican la orientación del sistema fijo al cuerpo
relativo al sistema fijo al espacio, y por tanto actúan como tres coordenadas
generalizadas. La transformación del sistema del espacio al sistema del cuerpo puede
lograrse a través de la matriz de transformación A, Eq.(1).
2.4.3. Definición
Dos sistemas ortogonales en el que se muestran los ángulos de Euler.
Dados dos sistemas de coordenadas xyz y XYZ con origen común, es posible
especificar la posición de un sistema en términos del otro usando tres ángulos α, β y γ.
La definición matemática es estática y se basa en escoger dos planos, uno en el

sistema de referencia y otro en el triedro rotado. En el esquema adjunto serían los
planos xy y XY. Escogiendo otros planos se obtendrían distintas convenciones
alternativas, las cuales se llaman de Tait-Bryan cuando los planos de referencia son
no-homogéneos (por ejemplo xy y XY son homogéneos, mientras xy y XZ no lo son).
La intersección de los planos escogidos se llama línea de nodos, y se usa para definir
los tres ángulos:
o α es el ángulo entre el eje x y la línea de nodos.

o β es el ángulo entre el eje z y el eje Z.
o γ es el ángulo entre la línea de nodos y el eje X.
11
La intersección de los planos coordenados xy y XY se llama línea de nodos. Más
adelante se establecerá que los tres ángulos de Euler descritos son los valores de las
tres rotaciones intrínsecas que describen el sistema.
Otra forma de poder explicar la convención utilizada para poder manejar los ángulos
Euler en panda es la siguiente.
Ángulos eulerianos o ángulos de navegación Yaw, pitch y Roll.
Yaw o guiñada: rotación con respecto al eje vertical o Y.

Pitch o cabeceo: rotación con respecto al eje X.
Roll o alabeo: rotación con respecto al eje Z.
Estas rotaciones se muestran en las siguientes imágenes:
Z Y Y
+ - + - + -
X Z X
YAW PITCH ROLL
Estos sistemas de rotación a simple vista se observan sencillos, pero hay que tomar
en cuenta que al momento de rotar un solo eje afecta a los otros dos.
12
2.5. Modelado 3D
Es un "mundo conceptual en tres dimensiones" una representación esquemática

visible a través de un conjunto de objetos, elementos y propiedades que, una vez
procesados, se convertirán en una imagen y animación en 3D.
Este conjunto de características suele estar formado por objetos poligonales,

tonalidades, texturas, sombras, reflejos, transparencias, translucidez, refracciones,
iluminación (directa, indirecta y global), profundidad de campo, desenfoques por
movimiento, ambiente, punto de vista.
2.5.1. Herramientas de modelado
Aquí un par de ejemplos de herramientas para modelado en 3D.
Animator Es un programa de modelado en 3D gratuito desarrollado R. Steven

Glanville. Donde se podrás crear y editar objetos, figuras y escenas tridimensionales,
partiendo de las formas más básicas. El programa tiene además soporte para fuentes
TrueType, realiza operaciones en tiempo real basadas en OpenGL y es capaz de
importar ficheros 3DS (3D Studio), LWO (Lightwave) y OBJ (Wavefront), crear
animaciones y escenas 3D exportando a vídeo AVI e imagen JPG o BMP, trabajar con
texturas, sombras, focos de luz y mucho más.
Blender es un programa multiplataforma, dedicado especialmente al modelado y

creación de gráficos tridimensionales. El programa fue inicialmente distribuido de
forma gratuita pero sin el código fuente, con un manual disponible para la venta.
Actualmente es compatible con todas las versiones de Windows, Mac OS X, Linux,
Solaris, FreeBSD e IRIX.
2.6. Personajes Virtuales
Los personajes virtuales son actores animados representados por medio de una
computadora que coexisten dentro de un universo virtual con la finalidad de interactuar
con el usuario. Existen dos tipos de personajes virtuales, los avatares, controlados por
un humano y los agentes virtuales inteligentes que tienen un comportamiento regido
por un diseño o fórmula computacional con un objetivo en específico.
Hoy en estos tiempos, el desarrollo modelos de objetos 3D y su animación es de gran

importancia para aquellos que se interesan a la programación de videos juegos con
fines ludo-educativos.
Antes de animar personajes virtuales, es necesario crearlos. Para su creación se

utiliza herramientas para el modelado de Grafico 3D por computadora.
13
2.6.1. Mundos Virtuales
Mediante los mundos virtuales, la computadora permite una percepción de estímulos

al usuario, quien a su vez puede manipular los elementos del mundo creado por la
computadora y por lo tanto las experiencias de telepresencia hasta cierto punto.
Tal modelado de mundos puede lucir similar al mundo real o puede representar
mundos de fantasía. Esto se logra simulando reglas basadas en el mundo real.
Ejemplos de estas reglas son la gravedad, la topografía, la locomoción, las acciones
en tiempo real, y la comunicación. Entre los aspectos principales de la comunicación
entre usuarios puede variar desde texto, iconos gráficos, gesticulaciones visuales,
sonido, y raramente, formas mediante el tacto, comandos de voz, y sensores de
balance.
Los mundos virtuales no están limitados a los juegos pero, dependiendo del grado de
urgencia presentado, pueden abarcar conferencias por computadora, y salas de charla
basadas en texto. Algunas veces, están disponibles emoticones y “smilies”, para
mostrar sentimientos o expresiones faciales. Según Edward Castronova un mejor
termino para estos ciberespacios es “mundos sintetizados”.
2.6.2. Mundos Virtuales en la Educación
Los mundos virtuales representan un poderoso nuevo medio para la instrucción y la

educación. Permite la constancia para poder continuar y hacer crecer las interacciones
sociales, las cuales pueden servir como bases para la colaboración educativa.
El uso de mundos virtuales puede darles a los maestros la oportunidad de tener un
mayor nivel de participación por parte de los alumnos. Esto permite a los usuarios
llevar a cabo tareas que podrían ser difíciles en el mundo real debido a las limitaciones
y restricciones, como lo son el costo, calendarización o la ubicación. Los mundos
virtuales tienen la capacidad de adaptarse y crecer a las diferentes necesidades de los
usuarios. Pueden ser una buena fuente de retroalimentación del usuario, los típicos
recursos basados en papel tienen limitaciones que los mundos virtuales pueden
superar.
Los mundos virtuales permiten a los usuarios con requerimientos y necesidades
específicas tener acceso y uso a los mismos materiales de aprendizaje desde casa, ya
que los recibiría como si estuviera en la presentación. Con la opción de permitir asistir
a una presentación vía un mundo virtual desde su casa o su lugar de trabajo, puede
ayudar al usuario estar más tranquilo y confortable. Esto puede ayudar a los usuarios
a mantenerse al día con las necesidades y la información relevante, mientras que
siente que se está involucrado.
La flexibilidad de los mundos virtuales ha mejorado enormemente las opciones de
estudio para los alumnos y la colaboración de negocios. A pesar de que los mundos
virtuales son una buena forma de comunicación e interacción entre los estudiantes y
maestros, esto no es substituto para las actuales reuniones cara a cara. Cuando
usamos mundos virtuales, existen desventajas en las que se pierde el lenguaje
corporal, y otros más aspectos personales.
14
2.7. Actores en Panda3D
La clase actor de Panda3D está diseñada para trabajar modelos animables y sus
animaciones.
No hay que confundir la clase de actor con la clase ActorNode, que se utiliza para la
física. Son completamente clases no relacionadas con nombres similares.
La clase de actor debe ser importado antes de cualquier carga o manipulación de los
actores.
from direct.actor.Actor import Actor
Una vez cargado el módulo, el objeto actor debe ser construido, y el modelo y las
animaciones debe cargarse:
Cargando cada animación requiere: el nombre está dando a la animación y la ruta de

acceso a la animación. Todo este proceso puede reducirse a un solo comando:
nodePath=Actor('ModelPath',{
'AnimationName1':'AnimationPath1',
'AnimationName2':'AnimationPath2',
})
Las animaciones también pueden ser descargadas utilizando la misma sentencia

utilizada en su creación.
nodePath.unloadAnims({'Animation Name':'Animation Path'})
2.8. Animaciones
2.8.1 Animación Básica
Las animaciones puede ser jugadas una vez (play) o en bucle (loop). Cuando se
reproduce una animación en bucle la animación se reproduce de forma continua. No
hay interpolación entre el último y el primer cuadro, así que si la animación va a ser
puesto en loop, debe ser construido con esa idea en mente.
Las animaciones se pueden detener en cualquier punto (stop). Cuando se detiene la

animación, el actor se quedará en la posición en que se detuvo.
actor.play('AnimationName')
actor.loop('AnimationName')
actor.stop()
Usted puede usar pose() para decirle a un actor que mantenga una posición en
particular en la animación. Las posiciones son numeradas comenzando en 0.
15
actor.pose('Animation Name', FrameNumber)
Posicionar un actor en cuadro no significa que automáticamente se especifique el

fotograma de inicio de la siguiente animación. Si no se desea iniciar en el primer
cuadro, se puede especificar usando los parámetros opcionales fromFrame y toFrame
en los métodos play () y loop ():
actor.play('AnimationName',fromFrame=10)
actor.loop('Animation Name', fromFrame = 24, toFrame = 36)
El método loop tiene un parámetro opcional denominado reiniciar, que es 1 por

defecto, reiniciando desde el principio. Si se asigna 0 en su lugar la animación va a
comenzar a partir de la posición actual:
actor.pose('AnimationName',30)
actor.loop ('Animation Name', restart = 0, fromFrame = 24, toFrame = 36)
2.8.2 Animación de Medio Cuerpo
Si desea que diferentes partes de un actor reproduzcan animaciones por separado, se

pueden crear las subpartes. Cada uno de estas puede jugar una animación sin influir
en los demás. Llame actor.makeSupart () con el nombre deseado, una lista de las
articulaciones que se incluirán y una lista de las articulaciones que deben excluirse en
la subparte. La inclusión o exclusión se extiende a las articulaciones adjuntas.
actor.makeSubpart("legs", ["Left Thigh", "Right
Thigh"])actor.makeSubpart("torso", ["Head"], ["Left Thigh", "Right Thigh"])
Si quieres reproducir una animación en una subparte asegúrese de pasar el nombre.

actor.loop("walk", partName="legs")
actor.loop("reload", partName="torso")
2.9. Intervalos
El uso de intervalos permite construir una compleja interacción de animaciones,

efectos de sonido, o cualquier otra acción, y reproducir la secuencia de comandos.
El núcleo del sistema es la clase de intervalo. Hay varios tipos diferentes de intervalos,
que se discutirá en detalle en las páginas siguientes, pero todos ellos tienen en común
los siguiente: cada intervalo representa una acción (o una serie de acciones) que
ocurren durante un intervalo específico, finito de tiempo.
El poder real del sistema de intervalo viene a partir de secuencias y Parallels, que son
un tipo especial de intervalo que puede contener intervalos anidados de cualquier tipo
(incluidas las secuencias adicionales y / o paralelos). Mediante el uso de estos
16
intervalos de agrupación, usted puede fácilmente montar secuencias de comandos
complejas de los átomos de base.
2.9.1. Intervalos de Actores
Los Intervalos permiten que las animaciones de un actor se combinen con otros
intervalos, a través de secuencias y paralelismos.
Se puede especificar el subrango de la animación para jugar a través de los

parámetros (Startframe hasta el endFrame) o especificando los segundos (startTime
hasta el tiempo del fin). Si no se especifica ninguno de estos, el valor por defecto es
jugar toda la animación.
Si el valor de endFrame es anterior a Startframe, o si el tipo de juego es negativo,

entonces la animación se reproducirá hacia atrás.
El parámetro constrainedLoop = 1 implica un bucle dentro de Startframe y endFrame
Todos los parámetros adicionales al nombre de animación son opcionales.

From direct.interval.ActorInterval import ActorInterval
myInterval = myactor.actorInterval(
"Animation Name",
loop=<0 or 1>,
contrainedLoop=<0 or 1>,
duration=D,
startTime=T1,
endTime=T2,
startFrame=N1,
endFrame=N2,
playRate=R,
partName=PN,
lodName=LN,
)
2.9.2. Uso de Intervalos
En cualquier módulo Panda3D que utiliza intervalos, primero debe importar el módulo
de intervalo:
from direct.interval.IntervalGlobal import *
Para iniciar un juego de intervalo, utilice uno de los siguientes métodos:
interval.start()
interval.start(startT, endT, playRate)
interval.loop()
interval.loop(startT, endT, playRate)
Los tres parámetros son opcionales. Los parámetros startTime y del tiempo del fin
define el subconjunto del intervalo de jugar, que deben darse en los tiempos en
17
segundos, desde el inicio del intervalo. El parámetro playRate, si se especifica, permite
jugar un intervalo más lento o más rápido que en tiempo real, su valor por defecto es
1.0, para jugar en tiempo real.
Normalmente, un intervalo jugará hasta el final y se detendrá por sí mismo, pero se

puede detener a un intervalo de juego antes de tiempo:
interval.finish()
Esto detendrá el intervalo y se mueven de su estado a su estado final, como si hubiera

jugado hasta el final. También puede temporalmente especificar una pausa y
reanudar un intervalo:
interval.pause()
interval.resume()
Si hace una pausa de un intervalo y no se reanuda, las acciones restantes en el

intervalo no se realizarán.
Es posible saltar en el tiempo dentro de un intervalo:
interval.setT(time)
A continuación se presentan otros métodos:
interval.getDuration()
Devuelve la longitud del intervalo en segundos.
interval.getT()
Devuelve el tiempo transcurrido en curso dentro del intervalo, desde el comienzo del
intervalo.
interval.isPlaying()
Devuelve true si el intervalo se está reproduciendo, o false si no se inició, ya ha
terminado, o ha sido explícitamente una pausa o terminado.
interval.isStopped()
Devuelve true si el intervalo no se ha iniciado, ya ha jugado a su conclusión, o se ha
detenido explícitamente a través de acabado (). Esto no es lo mismo como (not
interval.isPlaying ()), ya que no devuelve true para un intervalo de pausa.
18
Capítulo III. Descripción del Proyecto
En este capítulo se describirán los requisitos que fueron necesarios para llevar a cabo
el presente proyecto de residencias.
3.1. Descripción General del Proyecto
El proyecto realizado durante el desarrollo de la presente residencia, consiste en la

Creación de Animaciones en Tiempo Real, para tal fin tomaremos como base la
representación de un Modelo llamada “Ralph”.
Durante el desarrollo del proyecto se realiza una revisión de la lectura enfocada en el

desarrollo de mundos 3D, posteriormente se establecerá la metodología que se
seguirá durante el desarrollo del mismo. Se estudian los diferentes movimientos de las
partes de un cuerpo, así como las partes que conforman las mismas, y por ultimo se
realizara la manipulación de cada una de las partes del cuerpo.
3.2. Metodología del Proyecto
De acuerdo a las características del proyecto, la metodología de desarrollo de

sistemas que más se adapta al proyecto, es la metodología de desarrollo de
prototipos.
Una definición de un prototipo en software podría ser :
"...es un modelo del comportamiento del sistema que puede ser usado para entenderlo
completamente o ciertos aspectos de él y así clarificar los requerimientos... Un
prototipo es una representación de un sistema, aunque no es un sistema completo,
posee las características del sistema final o parte de ellas"
Fines de los Prototipos
El prototipo es una aplicación que funciona. La finalidad del prototipo es probar varias
suposiciones formuladas por analistas y usuarios con respecto a las características
requeridas del sistema. Los prototipos se crean con rapidez, evolucionan a través de
un proceso interactivo y tienen un bajo costo de desarrollo.
Objetivos de los Prototipos
Los objetivos de los prototipos son:

a) aclarar los requerimientos de los usuarios
b) verificar la factibilidad del diseño del sistema
19
Razones para emplear los Prototipos
Las razones para emplear los prototipos son:

a) aumentar la productividad
b) redesarrollo planificado
c) entusiasmo de los usuarios respecto a los prototipos
Un ejemplo de etapas de método con prototipos seria:

1- Identificación de requerimientos conocidos.
2- Desarrollo de un modelo de trabajo.
3- Participación del usuario.
4- Revisión del prototipo.
5- Iteración del proceso de refinamiento.
El método con prototipos o construcción de los mismos se puede graficar de la

siguiente manera:
20
A continuación se describe la metodología general que se siguió en el desarrollo del
proyecto para la investigación de los métodos de Panda3d que manipulan las
animaciones y los huesos de actores:
1. Revisión de literatura sobre Animación y Modelado 3D.

La revisión de la literatura para construir el marco teórico se centra en:
1) Personajes virtuales,
2) Modelado y animación de objetos 3D y personajes
3) Software de modelado 3d
.
2. Revisión de literatura sobre Animación de Huesos en Panda 3D

Revisión bibliográfica de métodos y funciones que manipulan esqueletos.
3. Identificación de Propiedades y funciones que trabajan con Huesos y

Esqueletos.
Con la revisión de prototipos ya previamente hechos se analizan las
propiedades y funciones de las animaciones de huesos y esqueletos para
identificar sus propiedades y a si poder desarrollar su documentación.
4. Desarrollo de prototipo y documentación que ilustre el proceso de

Desarrollo de prototipos de las funciones y Documentación de los procesos que
implican la animación de objetos y esqueletos.
5. Desarrollo de biblioteca de funciones que animan las diferentes partes del

cuerpo.
Con el estudio del esqueleto y los huesos específicos se desarrolla una
biblioteca de funciones que facilitara el como animar las diferentes partes del
cuerpo.
6. Desarrollo de prototipo que ilustra el funcionamiento de la biblioteca de

funciones.
Se desarrolla un prototipo que ilustra el funcionamiento de la biblioteca de
funciones mostrando el movimiento de las partes del cuerpo que se verán
afectadas.
21
3.3. Análisis de los Requerimientos
A continuación se presenta el resultado de nuestro análisis de requerimientos, el cual

se divide en 3 áreas.
3.3.1. Infraestructura Física
Una computadora de Escritorio

Procesador: Celeron @ 2.6 GHZ
Memoria RAM: 1 GB
Tarjeta de Video: VIA/S3G UniChrome Pro IGP @ 64MB
Una Computadora de Escritorio

Procesador: Pentium IV @ 3.2 GHZ
Memoria RAM: 2 GB
Tarjeta de Video: ATI Radeon 2500 @ 256 MB
Una Laptop Sony Vaio

Procesador: Intel Core2Duo P8700 @ 2.53 GHZ
Memoria RAM: 4 GB
Tarjeta de Video: NVIDIA GeForce GT230M @ 512 MB
Conexión a Internet
3.3.2. Software
El intérprete de Python, el cual está disponible en multitud de plataformas (UNIX,

Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que si no utilizamos librerías
específicas de cada plataforma nuestro programa podrá correr en todos estos
sistemas sin grandes cambios.
3.3.3. Infraestructura Humana
La infraestructura humana que se necesitó para llevar a cabo la realización del

presente proyecto fue de dos ingenieros en sistemas computacionales, para la
manipulación de las diferentes partes de un cuerpo.
22
Capítulo IV. Desarrollo del Proyecto
En este capítulo se describirán las actividades que fueron realizadas durante la

realización del proyecto de residencias, así como también los pasos para cada una de
las actividades más significativas realizadas en el software que se mencionó en el
capitulo anterior.
4.1. Descripción de las actividades realizadas
Las actividades que se llevaron a cabo durante la realización del proyecto de

residencias, se dividieron para cada uno de los participantes del mismo en dos
vertientes, que son: la animación facial, tronco y cabeza, y la animación de brazos,
manos, piernas y pies.
Las actividades que realizó el residente Iván de Jesús Palomera Hervert se

enfocaron en la animación de brazos, manos, piernas y pies, y las actividades
realizadas fueron:
1. Revisión de literatura sobre Animación y Modelado 3D

Esqueletos.
5. Desarrollo de biblioteca de funciones que animan partes del cuerpo
como son brazos, manos, piernas y pies.
6. Desarrollo de prototipo que ilustra el funcionamiento de la biblioteca
de funciones
Las actividades que realizara el residente Marco Polo Hernández Ruiz se enfocaron
en la animación facial, tronco y cabeza:
1. Revisión de literatura sobre Animación y Modelado 3D.

Esqueletos.
23
5. Desarrollo de biblioteca de funciones que animan partes del cuerpo
tales como cara, tronco y cabeza.
6. Desarrollo de prototipo que ilustra el funcionamiento de la biblioteca
de funciones
4.2. Procedimiento del desarrollo de residencias
En esta sección se dará una descripción de los procedimientos más significativos que
se realizaron al momento de desarrollar las residencias, así como también el proceso
de instalación del software utilizado en este proyecto.
4.2.1. Instalación del Software
4.2.1.1. Instalación de Pype (editor de programación)
Los pasos a seguir para poder utilizar este editor son los siguientes:
1.- Se descarga el archivo PyPE-2.9-win-unicode.zip que se encuentra en la

siguiente página: http://sourceforge.net/projects/pype/ y el cual solo pesa 8.3 MB.
24
2.- Descomprimimos el archivo anteriormente descargado en la ubicación que
nosotros deseemos, esto será solo una carpeta.
3.- Dentro del folder de PyPE se encuentra el ejecutable llamado pype.exe, y solo
daremos un doble clic para poder abrir la ventana del editor.
5.- Y al final se muestra la ventana del editor de pyhon.
25
4.2.1.2. Descarga e instalación de Panda3D
En la siguiente secuencia de pasos se mostrara el cómo poder descargar el motor de

juego Panda3D y su proceso de instalación.
1.- Para poder descargar este motor de juego primeramente se tendrá que acceder a
la página que es la siguiente http://www.panda3d.org/
2.- Para poderlo descargar nos tendremos que ubicar en la pestaña que dice
Download y en la opción de SDK donde daremos clic.
26
3.- En la imagen anterior se puede observar las versiones de Panda3D y para los
sistemas operativos en los que se puede manejar. Nosotros ocuparemos la versión
1.7.0 para Windows.
4.- Cuando se haya descargado el ejecutable solo le daremos doble clic para poder
instalar el Panda3D.
5.- En la ventana anterior solo daremos clic en el botón de Next.
27
6.- En esta ventana solo pide la aceptación de términos y condiciones de Panda3D.
7. Indicaremos la ubicación en la que queremos que se instale este motor de

juegos.
28
8.- Y solo daremos en el botón de finalizar para que quede instalado y poderlo
utilizar.
4.2.2. Geometría Básica en Panda3D
Para poder entender la forma en que se maneja el motor de juegos Panda3D

tendremos que ver los tipos de geometrías que se pueden manejar en él.
Hay dos clases de Panda3D de geometría 3D: El "modelo", que es para la geometría
no-animados, y el 'actor', que es para la geometría de animación.
Hay que tener en cuenta que sólo se considera la geometría animada si cambia de
forma. Así, por ejemplo, una pelota de béisbol no se considera animado, puede volar
por todo el lugar, pero se mantiene una esfera. Una pelota de béisbol sería un modelo,
no un actor.
4.2.3. Formato de Archivo Primario de Panda.
En Panda3D se maneja un formato de archivo primario llamado .egg, este archivo

puede contener:
* Un modelo (geometría estática)

* Un actor de reparto (de geometría dinámica)
* Una animación (que se aplicará a un actor)
* Un actor y una animación.
Este formato .egg es el que se maneja para poder ver las articulaciones que contiene
el actor a controlar.
Los archivos .egg se crean mediante la exportación de modelos de programas de

modelado 3D como Maya, Max, o Blender. En la actualidad, el apoyo a Maya es muy
29
fuerte, ya que los desarrolladores de Panda3D utilizan principalmente Maya. El
exportador de Max no es muy fiable ahora. Hay un tercer exportador para Blender, que
se dice que es bastante bueno. Esto es solo un comentario porque estos programas
son para poder crear los modelos y en este documento se manejaran actores ya
creados.
4.2.4. Manipulación de Ambiente o Escenario
Aunque nosotros no utilizaremos muy afondo esto, si es necesario que podamos saber
cómo cargar el escenario y algunas cosas esenciales.
Para hacer la utilización de un ambiente o escenario es necesario primero cargar el

modelo con el comando loader.loadModel
La función loader.loadModel ("models/nombre de ambiente") devuelve un objeto

Python que puede usarse como referencia del modelo cargado a lo largo del
programa.
Ejemplo de uso de loader.loadModel

nombreobjeto = loader.loadModel ("carpeta donde está el modelo /nombre del
modelo")
ambiente1 = loader.loadModel("models/environment")
En este caso el objeto al cual se va hacer referencia seria ambiente. En la figura 15 se

observa la carga de un ambiente, haciendo uso del comando loader.loadModel, como
se verá en el ejemplo del código siguiente.
Ejemplo del código de carga de un escenario:

import direct.directbase.DirectStart
#Cargar el modelo de ambiente
environ = loader.loadModel("models/environment")
environ.reparentTo(render)
environ.setScale(0.25,0.25,0.25)
environ.setPos(20,90,-5)
run()
30
Figura 15: Muestra de escenario cargado
4.2.5. Movimiento de la cámara
El poder manipular la cámara es otro de los puntos que tomaremos en cuenta para
poder enfocar o rotar sobre las imágenes.
Por defecto, Panda3D lleva a cabo una tarea que le permite mover la cámara
utilizando el ratón. Las claves para ello son:
• Botón Izquierdo: Si se mantiene presionado el botón izquierdo del Mouse la

cámara se mueve en la ventana de acuerdo a la dirección hacia donde se
desplace el Mouse.
• Botón Derecho: Al mantenerse presionado el botón derecho del Mouse y

desplazarlo hacia delante, la cámara se alejara más del modelo que se esté
ejecutando y se verá como es enviado hacia atrás de la ventana, si por el
contrario el Mouse es desplazado hacia atrás, la cámara se moverá hacia
enfrente y el modelo se observara más cercano.
• Botón Central: Hace girar la cámara en torno al modelo que fue cargado.
• Derecho y Medio Botones: La cámara gira en su mismo eje.
Se puede seguir adelante y tratar con este sistema de control de cámara. El problema
con este sistema de control de la cámara es que a veces es muy incómodo, no
siempre es fácil llevar a la cámara en la dirección que queremos.
31
En lugar de ello, vamos a utilizar una tarea que controla la posición de la cámara de
manera un poco más sencilla. Una tarea no es nada más que una subrutina que es
llamada en cada cuadro.
def SpinCameraTask (task):

angledegrees = task.time * 6.0
angleradians = angledegrees * (math.pi / 180.0)
base.camera.setPos(20*math.sin(angleradians),-20.0*math.cos(angleradians),2)
base.camera.setHpr(angledegrees, 0, 0)
return Task.cont
taskMgr.add(SpinCameraTask, "SpinCameraTask")
La función taskMgr.add le dice al administrador de tareas de Panda que llame a la

subrutina SpinCameraTask cada cuadro (frame). Esta es una subrutina que se ha
escrito para controlar la cámara. Mientras la subrutina SpinCameraTask devuelve la
constante Task.cont, el administrador de tareas la sigue llamando en cada cuadro.
La subrutina calcula la posición deseada de la cámara en base a cuánto tiempo ha

transcurrido. La cámara gira 6 grados cada segundo. Las dos primeras líneas son para
calcular la orientación deseada de la cámara, primero en grados, luego en radianes. El
método setPos establece la posición de la cámara. La función setHpr establece la
orientación.
Ahora se verá un ejemplo donde se utiliza una tarea para realizar el movimiento de la
cámara, utilizando también un escenario para observar el recorrido que hace la
cámara.
from direct.task import Task
import math
def SpinCameraTask(task):
angledegrees = task.time * 6.0
angleradians = angledegrees * (math.pi / 180.0)
base.camera.setPos(20*math.sin(angleradians),
20.0*math.cos(angleradians),2)
base.camera.setHpr(angledegrees, 0, 0)
return Task.cont
32
TaskMgr.add(SpinCameraTask, "SpinCameraTask")
#Cargar el modelo de ambiente
environ = loader.loadModel("models/environment")
environ.reparentTo(render)
environ.setScale(0.25,0.25,0.25)
environ.setPos(0,40,-5)
run()
En las figuras 17 y 18 se muestra como se realiza el movimiento de la cámara, la cual

gira alrededor de su eje y en la figura 17 se puede ver cuando inicia el movimiento y
en la figura 18 se muestra el recorrido que a tenido la cámara hasta ese momento.
Figura 17: Movimiento de cámara 1
33
Figura 18: Movimiento de cámara 2
4.2.6. Carga y Manipulación de Actores
Primero se carga la clase que contiene los métodos que permiten la utilización del
manejo de un actor, luego el actor y sus animaciones, para ser manipulados.
from direct.actor import Actor
Como siguiente paso se verá cómo se carga un actor y las animaciones por medio del
método Actor.Actor
Sintaxis
Nombredelobjeto = Actor.Actor ("ruta de la carpeta donde está el modelo
/nombre del modelo ",
{"Nombre para ejecutar esa la animación ":"Carpeta donde está el modelo /nombre de
la animación del modelo ",
"nombre2":" ruta de la carpeta/animacion2",
"nombre3":" ruta de la carpeta / animacion3"})
Ejemplo:
pandaActor = Actor.Actor("models/bvw-f2004--ralph/ralph",
{"walk":"models/bvw-f2004--ralph/ralph-walk",
"run":"models/bvw-f2004--ralph/ralph-run",
"jump":"models/bvw-f2004--ralph/ralph-jump"})
34
En las líneas anteriores se muestra cómo se puede cargar al actor y sus acciones.
Ahora veremos la manipulación de las animaciones de un actor, esto se realiza con

varios métodos de la clase que se cargó y que pueden ser aplicados a las
animaciones del actor, algunos de ellos son: play, loop, pose y stop.
Ejemplo de cada tipo de instrucción y como funciona:
Al utilizar el comando play la acción que se realiza es que el actor solo hace la
animación indicada una sola vez y luego se detiene.
Sintaxis:
Nombreobjeto.play(nombreanimacion)
pandaActor.play("run")
Al utilizar play con rango del frame (cuadro) en el que queremos que inicie al cuadro
en que deseamos que esta termine, hacemos que la animación solo realice este
movimiento una vez en el rango especificado.
Sintaxis:
Nombreobjeto.play(“nombreanimacion”, fromFrame = valor inicial , toFrame =
valor final)
pandaActor.play("jump", fromFrame = 0, toFrame = 90)
El comando loop al momento de ser aplicado a una de nuestras animaciones hará que
la animación seleccionada se realice de forma continua en un ciclo.
Y la sintaxis es la siguiente:
Nombreobjeto.loop(“nombreanimación”)
pandaActor.loop("run")
La instrucción pose, al ser ejecutada hace que la animación que se especifique se

quede parada en el valor del frame que fue asignada.
Sintaxis:
Nombreobjeto.pose(“nombreanimación”, valor del frame en el cual queremos que
se quede parado)
pandaActor.pose("run", 9)
El método stop al ser utilizado hace que la animación que está realizando el actor pare
quedándose inmóvil.
35
La sintaxis es:
Nombreobjeto.pose(“nombreanimación”)
pandaActor.stop()
Ejemplo de carga y animación de un actor
Este código de ejemplo hace uso de la clase Actor, carga el modelo y sus
animaciones, le da una escala al modelo, lo coloca en una posición y lo manda
mostrar en la pantalla y le activa un ciclo continuo donde el actor va a estar corriendo
en el mismo lugar.
#Esta clase permite la utilización del manejo de animación de un actor

from direct.actor import Actor
#Carga al actor, (donde primero se carga el modelo y luego sus #animaciones)

# y se corre el bucle de animación con la instrucción loop.
pandaActor = Actor.Actor("models/bvw-f2004--ralph/ralph",
{"walk":"models/bvw-f2004--ralph/ralph-walk",
"run":"models/bvw-f2004--ralph/ralph-run",
"jump":"models/bvw-f2004--ralph/ralph-jump"})
pandaActor.setScale(0.35,0.35,0.35)
pandaActor.setPos(0,20,0)
pandaActor.reparentTo(render)
pandaActor.loop("run")
run()
# No hay que olvidar poner la function run() por que sin esta la animación no correrá.
4.2.7. Manejo del Teclado y Mouse
Cuando se carga a un actor éste puede realizar movimientos que pueden ser
manejados o manipulados por medio del teclado o ratón, pero para poder empezar a
manejar eventos que son producidos por el ratón o teclado se necesita importar la
clase DirectObject, con lo cual ya se puede usar el método accept el cual activa un
evento y realiza una llamada a una función, los nombre de eventos disponibles son los
nombres de las letras del teclado y los botones del ratón.
La clase que se carga para manejar los eventos es:

from direct.showbase import DirectObject
36
Ejemplo del uso del método accept.
Nombreobjeto.accpet(“nombre de evento”, función)
pandaActor.accept ("escape", sys.exit)
pandaActor.accept("3",llamaanimacion2)
A continuación se verá un prototipo realizado en el cual se ejemplifica el uso del

manejo de eventos que son generados ya sea por alguna letra o número del teclado o
por algún botón del ratón y serán aplicados para animar un actor haciendo uso de
instrucciones antes vistas como son play, pose, stop, loop, se verá también el manejo
de una imagen y texto en pantalla.
En la imagen anterior se ve la posición inicial con la que es llamada Ralph y en esta

misma pantalla se pueden apreciar las funciones que puede realizar como lo pueden
ser: correr, detenerse y saltar.
37
4.2.8. Animación de Actores
El cuerpo del actor está compuesto por varios huesos y uniones entre ellos llamados
joints, estos vienen simulando o representando las articulaciones de los huesos del
cuerpo humano, para poder dar forma y movimientos más reales o similares. Pero los
problemas con los que podemos toparnos es que al momento de dar movimiento estas
articulaciones rebasen el límite de lo que el cuerpo humano sería capaz, así que
primeramente se tendera que buscar la orientación de los joints para saber cómo
poder manipularlos y así dar un límite de movimiento.
Las articulaciones que maneja el actor se muestran en las siguientes imágenes:
Cuello
Hombro Hombro
Derecho Izquierdo
Codo
Codo
Izquierdo
Derecho
Cadera Cadera
derecha Muñeca Muñeca Izquierda
Derecha Izquierda
Mano Mano
Derecha Izquierda
Rodilla
Rodilla
Izquierda
Derecha
Tobillo
Tobillo Izquierdo
Derecho
Parpado
Parpado
Derecho
Izquierdo
Mejilla Mejilla
Derecho Izquierda
Labio
Superior
Parpado
derecho
38
Tomando en cuenta que es tanta la información que se tiene para poder realizar
movimientos con un actor solo veremos los puntos más importantes y después nos
enfocaremos en lo que es la manipulación de los huesos.
4.2.9. Manipulación de Actores
En este tema nos enfocaremos más a la manipulación de los actores y los métodos
que pueden ser utilizados.
Para comenzar se tiene que dar a conocer que hay dos métodos para revelar las
articulaciones, controlJoint y exposeJoint. Cada uno tiene un argumento 'Modelo
Nodo', que es generalmente la cadena, "modelRoot.". Asimismo, ambos quieren el
nombre de la articulación. Usted puede ver el nombre del hueso en un paquete de
modelado, o buscar una cadena como <Joint> dentro de un archivo egg.
Como ya se explicó anterior mente el archivo .egg es el que contiene las articulaciones
o joint del actor a manipular.
4.2.9.1. Animación de medio-cuerpo (makeSubpart)
Hay diferentes formas de darle animación a un cuerpo y una de ellas es utilizar el

método makesubpart(), si solo se desea dar movimiento a unas partes en específico.
39
Para poder ver los efectos el actor debe estar en alguna acción como pude ser
caminar.
Ralph = Actor.Actor("ralph",
{"camina":"ralph-walk"}) ## acción del actor
Ralph.setScale(1,1,1)# Escalar
Ralph.setPos(0,5,-1)#Posicionar
Ralph.setHpr(0,0,0)#Rotar
Ralph.reparentTo(render)
Ralph.makeSubpart("legs", ["LeftShoulder", "RightShoulder"])

## En la línea anterior se muestra la asignación de los nombres de cada
articulación que se afectará.
Ralph.loop("camina", partName="legs")
4.2.9.2. ExposeJoint
Este método puede es manejado cuando se quiere agregar un objeto más a la

articulación deseada, ya sea para que actor simule que sostiene algún objeto o
simplemente agregar algún adorno a este.
En la siguiente línea de código se muestra cómo se puede mandar a llamar el nodo de

la articulación deseada.
NodePath=ModelNodePath.exposeJoint(None,‘Model Node',‘Joint Name')
Esto crea una nueva NodePath de la NodePath del actor que sostiene el conjunto.
Aquí se muestra con un pequeño ejemplo la utilización del exposeJoint ().
40
mano_derecha = Ralph.exposeJoint(None, 'modelRoot', 'RightHand')
mano_izquierda = Ralph.exposeJoint(None, 'modelRoot', 'LeftHand')
sword = loader.loadModel("sword") #cargar el modelo
sword.setScale(.5) #Escala el modelo
sword.setHpr(90,0,90) #orienta el modelo en grados
sword.reparentTo(mano_derecha)# en esta línea se agrega la espada a la mano
derecha
candycane = loader.loadModel("candycane")
candycane.setScale(1)
candycane.setHpr(0,0,90)
candycane.reparentTo(mano_izquierda)
Ralph.accept("escape",sys.exit)
Para poder manipular una articulación se podrá utilizar el controlJoint ().
NodePath=ModelNodePath.controlJoint(None,‘Model Node',‘Joint Name')
Lo que hace que parezca que el actor este sosteniendo un objeto.
4.2.9.3. ControlJoint
Para poder realizar los movimientos con este método es importante saber las
orientaciones de cada joint o articulación del actor, estas orientaciones serán
mostradas cunando se manipulen cada uno de los joints por separado.
41
El método controlJoint es utilizado para poder controlar las articulaciones que
contenga el actor. En este método existen varias funciones que se pueden utilizar, a
continuación se mencionaran las que utilizaremos.
Pos()
Una de las formas en que se pueden manipular las articulaciones de los actores es
cuando esta se cambia de posición, la función que se utilizara será setPos(). A
continuación se mostrara con una pequeña parte del código lo que se puede hacer.
De igual manera se tiene que hacer uso de la función controlJoint para tener un tipo de
acceso a la articulación que se desee manipular. Se tiene que recordar que la
posición de la articulación se da en el plano x,y,z.
cuello = Ralph.controlJoint(None, 'modelRoot','Neck')
def mueve_cuello():
cuello.setPos(2,-5,2)## Posición de la articulación
En la imagen anterior se observa la posición normal del actor y en la imagen siguiente

se observa como la articulación del cuello ha cambiado de posición.
42
Hay que recordar que la función Pos() es para posicionar la articulación y es por eso
que se puede llegar a deformar el actor.
Hay diversas formas de poder manipular los huesos del actor, esto puede ser con
getPos() que sirve para posicionar el hueso o también con getHpr() que sirve para
orientar la parte del cuerpo que se desee cambiar.
Los valores utilizados para estas funciones son los grados, utilizando las coordenadas
en 3D y viendo cómo están orientados los huesos del actor.
Con la función getHpr() es posible manejar los tres valores xyz al mismo tiempo, pero
también es posible manejarlo por separado, hay que tener en cuenta que el tipo de
grados que se manejan en este caso serán los grados eurelianos. Con esto tenemos
que el valor asignado a H corresponde a x, el de P corresponde a y y el valor de R es
el valor de z.
Recordando cómo es que los grados eurelianos afectan el movimiento y rotación de

cada parte del cuerpo tenemos que los grados eurelianos son manejados de la
siguiente forma que x gira sobre z, y rota sobre sí mismo y lo que sucede con z es que
gira sobre x.
Teniendo el siguiente código se puede observar las diferentes funciones aunque

sencillas ilustran la forma en cómo se puede manipular los huesos del actor.
mano_derecha = Ralph.controlJoint(None, 'modelRoot', 'RightHand')
mano_izquierda = Ralph.controlJoint(None, 'modelRoot', 'LeftHand')
parpado_derecho = Ralph.controlJoint(None, 'modelRoot', 'RightEyeLid')
parpado_izquierdo = Ralph.controlJoint(None, 'modelRoot', 'LeftEyeLid')
labio_superior = Ralph.controlJoint(None, 'modelRoot','TopLip')
43
menton = Ralph.controlJoint(None,'modelRoot','Jaw')
brazoDerecho = Ralph.controlJoint(None,'modelRoot','RightShoulder')
brazoIzquierdo = Ralph.controlJoint(None,'modelRoot','LeftShoulder')
tobillo_derecho = Ralph.controlJoint(None, 'modelRoot', 'RightAnkle')
A continuación se presentan algunas funciones que se desarrollaron para activar la

funciones que se ilustran en la siguiente imagen.
def mueve_brazoIzquierdo(): #Definición de la acción del hueso

i=20+brazoIzquierdo.getP()
brazoIzquierdo.setP(i)
def mueve_brazoDerecho():
i=20+brazoDerecho.getH()
brazoDerecho.setH(i)
def mueve_menton():
i=20-Menton.getH()
Menton.setH(i)
def mueve_labio():
i=20-Labio_superior.getH()
Labio_superior.setH(i)
44
def mueve_parpadoDerecho():
k=90-parpado_derecho.getP()
parpado_derecho.setP(k)
def mueve_parpadoIzquierdo():
k=90-parpado_izquierdo.getP()
parpado_izquierdo.setP(k)
def mueve_manoDer():
i=-20-mano_derecha.getR()
mano_derecha.setR(i)
def mueve_manoIzq():
i=-20+mano_izquierda.getH()
j=-90+mano_izquierda.getP()
k=-20+mano_izquierda.getR()
mano_izquierda.setHpr(i,0,k)
def mueve_tobillo():
i=10+tobillo_derecho.getH()
tobillo_derecho.setHpr(i,0,0)
Ralph.accept("escape",sys.exit)
Ralph.accept("1",mueve_manoDer)
Ralph.accept("2",mueve_manoIzq)
Ralph.accept("3",mueve_parpadoDerecho)
Ralph.accept("4",mueve_parpadoIzquierdo)
Ralph.accept("5",mueve_labio)
Ralph.accept("6",mueve_tobillo)
Ralph.accept("7",mueve_menton)
Ralph.accept("8",mueve_brazoDerecho)
Ralph.accept("9",mueve_brazoIzquierdo)
run()
45
Variantes de la Hpr().
Este tema se enfoca más que nada en la función del Hpr() y las variantes que puede
llegar a tener en su utilización, las dos formas que se analizaron son al manejar los
tres movimientos del eje cartesiano en una sola función y la otra es manejando los
movimientos por separado en cada uno de los ejes.
Para ilustrar lo que se pretende hacer se presenta la siguiente imagen.
La animación de la izquierda es manipulada de los brazos de manera independiente

en los tres ejes, y la animación de la derecha es manipulada de los brazos con una
sola función para los tres ejes.
En el siguiente código se muestra la forma de manipularlos de las 2 maneras.

def mueve_hombroIzquierdo(self):
i=-90+self.hombroIzquierdo.getH()
self.hombroIzquierdo.setH(i)
def mueve_hombroIzquierdoP(self):
i=-90+self.hombroIzquierdo.getP()
self.hombroIzquierdo.setP(i)
def mueve_hombroIzquierdoR(self):
i=-90+self.hombroIzquierdo.getR()
self.hombroIzquierdo.setR(i)
46
En el código anterior se muestra que en donde se define mueve_hombroIzquierdo,
solo se está enviando a que el hombro de la animación sea manipulada sobre el eje x,
no hay que dejar pasar que los movimientos de los ejes no serán sobre ejes
cartesianos, si no que por los ángulos Eurelíanos.
def mueve_hombroIzquierdo2(self):
self.hombroIzquierdo2.setHpr(-90,-90,-90)
(En este fragmento de código se le está enviando que el movimiento se tiene que
hacer en los tres ejes al mismo tiempo).
Aquí se muestran algunos ejemplos de los movimientos que se pueden realizar.
En la imagen anterior se observa el movimiento del brazo derecho de cada una de las
animaciones, el movimiento de la animación de la derecha fue hecho con una sola
función en cambio el movimiento de la animación de la izquierda se realizó en tres
pasos donde primero se hizo el movimiento en el eje X, luego en el eje Y, y finalmente
en el eje Z.
En la siguiente imagen se muestra otro ejemplo del movimiento de las extremidades

de la animación en este caso es el brazo derecho de cada una de las animaciones, se
podrá observar que al hacer el movimiento con una sola función (es el caso del lado
derecho) este se coloca en una posición muy diferente si se hace el movimiento por
separado en cada uno de los ejes (animación del lado izquierdo). Para que la
extremidad que es manipulada independiente mente en sus ejes pueda ser colocada
en la ubicación similar a la que es manipulada con una sola función se tienen que
seguir una serie de secuencias.
47
Para lograr que dos animaciones quedaran en la misma posición en la animación de la
izquierda se calcularon los grados que se tenía que mover la extremidad en cada eje,
ya que cuando una animación se manda a llamar esta ya viene con los grados de cada
extremidad ya establecidos.
En este caso se igualo el brazo derecho de la animación de la derecha al brazo

derecho de la imagen de la izquierda. Los pasos que se siguieron fueron que primero
se roto sobre el eje Y, después se desplazó la extremidad sobre el eje Z y final mente
sobre el eje X.
48
4.2.3. Manipulación de Todas las Partes del Cuerpo
En esta sección se explicará cómo se pueden manipular las partes del cuerpo del
actor para dar la posición que más deseemos.
Inicialmente el actor tiene una posición un tanto extraña, pero con algunas funciones
en sus articulaciones le daremos una postura un más seria.
4.2.3.1. Movimiento de los Brazos
En la imagen anterior se puede apreciar que el brazo izquierdo del actor está en una
posición hacia atrás, lo que se realizará en seguida será darle una posición con ambos
brazos hacia abajo.
Para poder saber como y hacia donde realizar los movimientos de los brazos se tienen
se tomaron las orientaciones de cada cuna de las articulaciones que pueden afectar el
movimineto de ambos brazos.
Analizando cada joint por separado se pudieron observar sus coordenadas, esto
permitirá que al momento de querer hacer los movimientos sea más fácil saber sobre
que eje o ejes rotar la articulación.
Articulaciones del brazo derecho.
En esta extremidad se pueden observar las articulaciones del hombro, codo, muñeca y
mano.
49
Z
X
-Y Y
-X
-Z
X
Z
-Y Y
-Z
-X
Y
Z
-X X
-Z
-Y
X
-Z
y
-Y
-X
50
Estas son las funciones que se ocuparon para poder saber la posición inicial de las
articulaciones en este caso serán las del hombro izquierdo.
def mueve_codoIzquierdo(self):
self.codoIzquierdo.setHpr(0,0,0 )
## Esta línea se manda las coordenadas en cero de cada uno de los ejes
self.hombroIzquierdo.setHpr(0,0,0)
## esta línea manda la ubicación en cero de cada una de las coordenadas
para el hombro derecho.
En la imagen anterior se observa la posición de cero en lo que es la articulación del

hombro, y en la imagen siguiente se muestra la posición cero del codo.
51
A si que para llegar al resultado de la imagen siguiente se tuvo que aumentar los
grados para lograr la posición deseada, todo esto con la siguiente función.
self.codoIzquierdo.setH(180
Y de igual forma se siguieron los mismos pasos para el brazo derecho.
4.2.3.2. Movimiento de las Manos y Muñecas
Para poder mostrar estos movimientos se usa una función cuya acción será de la ida y
retorno, trabajaremos con el mismo actor pero ahora mostraremos como limitar los
movimientos.
En la imagen siguiente se muestra la posición inicial y final del actor.
52
A continuación se mostrara la función que hace que el movimiento sea limitado en los
grados.
def mueve_manoDer(self):
i=-60-self.mano_derecha.getR() ## Movimiento realizado sobre el eje z.
self.mano_derecha.setR(i)
En las imágenes anteriores los huesos que se manipularon son los de la muñeca
derecha y de igual forma se limita en el movimiento, su función es la siguiente.
def mueve_munecaDer(self):
i=-60-self.muneca_derecha.getP()
## En esta función se está manipulando los huesos en el eje y
self.muneca_derecha.setP(i)
53
En la secuencia de imágenes anterior se trata de mostrar el movimiento de la mano
izquierda, pero este movimiento es un tipo de secuencia la cual se maneja en los ejes
de X y Z. La función aplicada es la siguiente.
def mueve_manoIzq(self):
i=-20+self.mano_izquierda.getH()
k=-20+self.mano_izquierda.getR()
self.mano_izquierda.setHpr(i,0,k)
Ahora se muestra como se manipula la muñeca izquierda.

def mueve_munecaIzq(self):
i=-60-self.muneca_izquierda.getR()
self.muneca_izquierda.setHpr(i)
54
4.2.3.3. Manipulación de Pierna, Rodilla y Tobillo
A continuación se mostrara las articulaciones y las orientaciones de estas para poder

manipular mejor las piernas, rodillas y tobillos.
Los joints que se encargan de la manipulación de las piernas son los que representan
las caderas, así que se observara que estos están en el área del tronco del cuerpo
como a continuación se muestra en la siguiente imagen.
X
-Y X -Y
-Z
-Z Z
Z
Y Y
-X -X
Las articulaciones de las piernas las componen las rodillas y los tobillos, estas
articulaciones tienen las mismas orientaciones como a continuación se muestra en la
imagen siguiente.
- -
- -
X - X -
Z Z
Y Y
- -
- -
X - X -
Z Z
Y Y
55
Inicialmente la posición de las piernas son las comunes cuando una persona esta de
pie.
Sacando las coordenadas de la posición de las piernas, rodillas y tobillos estas están
en ceros en los tres ejes lo que hace más fácil su manipulación.
Primeramente se verá cómo se

pueden manipular las piernas.
Se mostrara como hacer un

movimiento de ida y vuelta
tratando de simular una patada.
56
Habiendo analizando anteriormente cuales son los ejes (por qué no todos los huesos
tienen la misma orientación) se observó que los ejes a manipular son el Y y Z.
La función que se manejo fue la siguiente.

def mueve_caderaIzquierda(self):
i=140-self.cadera_izquierda.getR()
## Al eje Z se le da la acción de ida y vuelta para q simule la patada.
self.cadera_izquierda.setHpr(0,60,i)
## Al eje Y se le da un valor estático solo para buena estética.
En segundo lugar se mostrara como manipular la rodilla.
Tomando la siguiente imagen como referencia se manejara la articulacion de la rodilla.
En la secuencia anterior se muestra el movimiento de rodilla el cual también es de ida

y vuelta, el código que fue utilizado para poder realizarlo es el siguiente.
def mueve_rodillaIzquierda(self):
i=90-self.rodilla_izquierda.getP()
## El eje manipulado es el eje Y, será el único apoyándose en la

estructura humana solo se puede mover en un sentido.
self.rodilla_izquierda.setP(i)
Y por último siguiendo con la secuencia manipularemos el tobillo.
57
La imagen anterior muestra la mitad de la acción que se quiere realizar, y el
movimiento del tobillo fue posible con la siguiente función.
def mueve_tobilloIzquierdo(self):
i=100-self.tobillo_izquierdo.getP( )
##El eje en el que es realizada la acción es en el eje Y .
self.tobillo_izquierdo.setP(i)
4.2.3.4. Movimientos de la Parte Superior del Actor.
El movimiento con el cual comenzaremos será con la posición del cuello.
En lo que es el tronco del cuerpo se pueden encontrar tres articulaciones que se

pueden manipular, estas son la que manipula el cuello y las ya antes mencionadas
que manipulan a las piernas que vendrían siendo las caderas izquierda y derecha.
Observando su articulación se puede deducir que los movimientos se pueden efectuar

sobre los 3 ejes, eso sí con diferentes limitantes de grados.
Empezaremos por el eje X, en el cual el movimiento es hacia adelante si es negativo el

valor o hacia atrás si es positivo el valor a continuación se muestra en las imágenes
siguientes.
58
Esto se logra con la siguiente función.
def mueve_cuello(self):
i=-30-self.cuello.getH()
self.cuello.setHpr(i,0,0)
Pero si se desea el movimiento hacia

atrás como el de la siguiente imagen se
tendrá que utilizar la función siguiente.
i=30-self.cuello.getH()
self.cuello.setHpr(i,0,0)
Para hacer un movimiento de rotación hacia la izquierda o hacia la derecha como el

que se muestra en las siguientes imágenes se utilizara la función siguiente.
i=50-self.cuello.getP()
self.cuello.setHpr(0,i,0)
La función presentada anteriormente hace que el movimiento del cuello después de la

posición inicial sea hacia la izquierda.
59
Pero si el movimiento que se quiere es hacia la derecha se utilizara la función
siguiente.
i=-50-self.cuello.getP()
self.cuello.setHpr(0,i,0)
Y finalmente cuando el movimiento que se desea es hacia los laterales el eje que se
ocupara será el eje Z, y dependiendo del lado que se quiera mover el cuello será la
función que se defina.
Para el lado derecho es la siguiente.

i=-30-self.cuello.getR()
self.cuello.setHpr(0,0,i)
Y la acción es la correspondiente a la
siguiente imagen.
En cambio si se desea mover hacia el

lado izquierdo la función es la que a
continuación se presenta.
i=30-self.cuello.getR()
60
4.2.3.5. Movimiento de los Parpados
Para poder saber cómo manipular cada uno de las articulaciones que existen en la
cara también fue necesario poder sacar la orientación década uno de los huesos que
se encuentran en el rostro, a continuación se muestran los joints encontrados con sus
respectivas orientaciones.
En el rostro se encuentran varias articulaciones como son: los parpados, las mejillas,
el labio superior y la barbilla.
Como se puede observar en la imagen siguiente los parpados tienen las mismas
orientaciones en los parpados, de igual forma las orientaciones de las mejillas son las
mismas y finalmente las orientaciones del labio superior y de la barbilla son similares.
Analizando la posición de los

huesos de ambos parpados, se
pudo notar que los dos están
posicionados en grados diferentes,
lo que se hizo fue poner los dos
parpados en la posición de cero en
todos los ejes y a continuación se
muestra el resultado.
61
Como se puede notar el parpado derecho tiende a deformarse y la textura de este no
logra cubrir todo el ojo, así que para mostrar lo que se puede hacer manejaremos el
parpado izquierdo.
Tratando de que el parpado no se deforme y observando los movimientos en cada eje,

nos pudimos dar cuenta que en el único eje en el que se puede manejar al parpado es
en el eje Y, a continuación se muestra los resultados.
A un que se llega a deformar un poco el parpado se logra hacer este pequeño

movimiento con la siguiente función.
def mueve_parpadoIzquierdo(self):
i=90-self.parpado_izquierdo.getP()
self.parpado_izquierdo.setHpr(0,i,0)
4.2.3.6. Manipulación de Mejilla, Mandíbula y Labio Superior
En estas articulaciones se tuvo algunos problemas porque al querer manipular cada

una de ellas la textura del actor no lograba cubrir algunas partes y no se obtenía el
resultado deseado.
Movimiento de las mejillas.
En la manipulación de este hueso se llegó a la conclusión de que en el único eje en el

que se puede manipular es en el eje Z ya que en los demás ejes el rostro del actor se
llegaba a deformar, pero el movimiento que se le dio es tan pequeño que apenas se
logra distinguir. A continuación se muestra el resultado de esta manipulación con
ambas mejillas.
62
Lo que se trata de hacer es hacer simulación donde la majilla izquierda se mueva en
una forma vertical de arriba hacia abajo con la siguiente función.
def mueve_mejillaIzquierda(self):
i=-200-self.mejillaIzquierda.getR()
self.mejillaIzquierda.setR(i)
Movimiento de la barbilla.
En esta articulación el movimiento será manipulado sobre el eje X, esto simulara como
si el actor estuviese abriendo la boca, pero solo que habrá un pequeño problema con
la textura ya que esta cubre lo que son los dientes, y el movimiento solo se podrá notar
por la parte lateral del actor.
A continuación se muestra como actúa siguiente función.

def mueve_barbilla(self):
i=-90-self.barbilla.getH()
self.barbilla.setH(i)
63
Movimiento del labio superior.
Este es el último hueso a manipular en el rostro del actor y es algo simple y sencillo,
ya que este movimiento se hará sobre el eje X como el de la barbilla y será con la
siguiente función.
def mueve_labio(self):
i=20-self.Labio_superior.getH()
self.Labio_superior.setH(i)
Manteniendo la imagen anterior del actor con la barbilla hacia abajo manipularemos el
labio para que sea un poco más visible.
Con esto terminamos con la manipulación de cada una de las articulaciones que tiene
este actor y a continuación se mostrara el programa completo.
from panda3d.core import CollisionTraverser,CollisionNode
from panda3d.core import CollisionHandlerQueue,CollisionRay
from panda3d.core import Filename,AmbientLight,DirectionalLight
from panda3d.core import PandaNode,NodePath,Camera,TextNode
from panda3d.core import Vec3,Vec4,BitMask32
from direct.gui.OnscreenText import OnscreenText
from direct.actor.Actor import Actor
from direct.showbase.DirectObject import DirectObject
import random, sys, os, math
## Se comenzara llamando a las librerías a utilizarlas cuales cargan al actor,

##otras nos ayudan a manipular al actor y otras más nos ayudan a la
##manipulación de la cámara.
SPEED = 0.5
class World(DirectObject):
## En la clase World se cargara todo el entorno en los movimientos que se

##harán con la cámara y los movimientos al actor, en este caso llamado Ralph.
def __init__(self):
self.keyMap = {"cam-left":0, "cam-right":0}
64
## En las siguientes cuatro líneas se cargara al actor, también se cargara una
## de las acciones que puede realizar como lo es el caminar, tambien se escala
## al actor se posiciona en la pantalla y finalmente se carga.
self.ralph = Actor("ralph",{"camina":"ralph-walk"})
self.ralph.setScale(1)
self.ralph.setPos(0,5,-1)
self.ralph.reparentTo(render)
## También es podsible agregar objetos a los joints, como se ha visto
##anterior mente.
self.manoDerecha = self.ralph.exposeJoint(None, 'modelRoot',
'RightHand')
self.manoIzquierda = self.ralph.exposeJoint(None, 'modelRoot', 'LeftHand')

## Se cargan los modelos los cuales se decean agregar a la articulacion de la
##mano.
self.sword = loader.loadModel("sword")
self.sword.setScale(.5)
self.sword.setHpr(90,0,90)
self.sword.reparentTo(self.manoDerecha)
self.candycane = loader.loadModel("candycane")
self.candycane.setScale(1)
self.candycane.setHpr(0,0,90)
self.candycane.reparentTo(self.manoIzquierda)
self.floater = NodePath(PandaNode("floater"))
self.floater.reparentTo(render)
## En las lineas de codigo siguiente se hacen validar los movimientos de la

##camara con el teclado.
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["cam-left",1])
self.accept("arrow_right", self.setKey, ["cam-right",1])
self.accept("arrow_left-up", self.setKey, ["cam-left",0])

self.accept("arrow_right-up", self.setKey, ["cam-right",0])
## En el codigo siguiente se validan los movuimientos del actor activados por

## el teclado
self.ralph.accept("escape",sys.exit)
self.ralph.accept("1",self.mueve_manoDer)
self.ralph.accept("2",self.mueve_manoIzq)
self.ralph.accept("3",self.mueve_munecaDer)
self.ralph.accept("4",self.mueve_munecaIzq)
self.ralph.accept("c",self.mueve_caderaIzquierda)
self.ralph.accept("r",self.mueve_rodillaIzquierda)
self.ralph.accept("t",self.mueve_tobilloIzquierdo)
self.ralph.accept("p",self.mueve_parpadoDerecho)
self.ralph.accept("o",self.mueve_parpadoIzquierdo)
self.ralph.accept("l",self.mueve_labio)
self.ralph.accept("z",self.mueve_cuello)
self.ralph.accept("b",self.mueve_barbilla)
self.ralph.accept("8",self.mueve_brazoDerecho)
self.ralph.accept("9",self.mueve_hombroIzquierdo)
self.ralph.accept("p",self.mueve_parpadoDerecho)
self.ralph.accept("i",self.mueve_codoIzquierdo)
65
self.ralph.accept("n",self.mueve_mejillaIzquierda)
self.ralph.accept("m",self.mueve_mejillaDerecha)
self.ralph.accept("v",self.animacion_camina)
self.ralph.accept("q",self.pose_inicial_ralph)
taskMgr.add(self.move,"moveTask")
## A continuación se les asigna un nombre a cada una de las articulaciones.
self.mano_derecha = self.ralph.controlJoint(None, 'modelRoot',

'RightHand')
self.mano_izquierda = self.ralph.controlJoint(None, 'modelRoot',
'LeftHand')
self.muneca_derecha = self.ralph.controlJoint(None, 'modelRoot',
'RightWrist')
self.muneca_izquierda = self.ralph.controlJoint(None, 'modelRoot',
'LeftWrist')
self.cadera_izquierda = self.ralph.controlJoint(None, 'modelRoot', 'LeftHip')
self.rodilla_izquierda = self.ralph.controlJoint(None, 'modelRoot',
'LeftKnee')
self.tobillo_izquierdo = self.ralph.controlJoint(None, 'modelRoot',
'LeftAnkle')
self.parpado_derecho = self.ralph.controlJoint(None, 'modelRoot',
'RightEyeLid')
self.parpado_izquierdo = self.ralph.controlJoint(None, 'modelRoot',
'LeftEyeLid')
self.Labio_superior = self.ralph.controlJoint(None, 'modelRoot','TopLip')
self.barbilla = self.ralph.controlJoint(None,'modelRoot','Jaw')
self.brazoDerecho = self.ralph.controlJoint(None,'modelRoot','RightShoulder')
self.hombroIzquierdo =self.ralph.controlJoint(None,'modelRoot','LeftShoulder')
self.codoIzquierdo = self.ralph.controlJoint(None,'modelRoot','LeftElbow')
self.cuello = self.ralph.controlJoint(None, 'modelRoot','Neck')
self.mejillaDerecha = self.ralph.controlJoint(None, 'modelRoot','RightCheek')
self.mejillaIzquierda = self.ralph.controlJoint(None, 'modelRoot','LeftCheek')
##Se desactiva el movimineto con el mouse.

base.disableMouse()
base.camera.setPos(self.ralph.getX(),self.ralph.getY()+10,2)
## Se definen cada una de los metodos a realizar.Estos metodos son cada uno de
##los movimientos que el actor podrarealizar.
def pose_inicial_ralph(self):
self.ralph.pose("camina",6)
def animacion_camina(self):
self.ralph.loop("camina")
def mueve_mejillaDerecha(self):
i=-200-self.mejillaDerecha.getR()
self.mejillaDerecha.setR(i)
def mueve_mejillaIzquierda(self):
i=-200-self.mejillaIzquierda.getR()
self.mejillaIzquierda.setR(i)
66
i=30-self.cuello.getR()
def mueve_caderaIzquierda(self):
i=140-self.cadera_izquierda.getR()
self.cadera_izquierda.setHpr(0,60,i)
def mueve_rodillaIzquierda(self):
i=90-self.rodilla_izquierda.getP()
self.rodilla_izquierda.setP(i)
def mueve_tobilloIzquierdo(self):
i=90-self.tobillo_izquierdo.getP()
self.tobillo_izquierdo.setP(i)
self.codoIzquierdo.setH(180)
def mueve_brazoDerecho(self):
i=20+self.brazoDerecho.getH()
self.brazoDerecho.setHpr(i,0,0)
def mueve_barbilla(self):
i=-90-self.barbilla.getH()
self.barbilla.setH(i)
def mueve_labio(self):
i=20-self.Labio_superior.getH()
self.Labio_superior.setH(i)
def mueve_parpadoDerecho(self):
i=90-self.parpado_derecho.getP()
self.parpado_derecho.setHpr(0,i,0)
def mueve_parpadoIzquierdo(self):
i=90-self.parpado_izquierdo.getP()
self.parpado_izquierdo.setHpr(0,i,0)
def mueve_manoDer(self):
i=-60-self.mano_derecha.getR()
self.mano_derecha.setR(i)
def mueve_manoIzq(self):
i=-20+self.mano_izquierda.getH()
k=-20+self.mano_izquierda.getR()
self.mano_izquierda.setHpr(i,0,k)
def mueve_munecaDer(self):
i=-60-self.muneca_derecha.getP()
self.muneca_derecha.setP(i)
def mueve_munecaIzq(self):
i=-60-self.muneca_izquierda.getR()
self.muneca_izquierda.setHpr(i)
67
def setKey(self, key, value):
## En las siguientes lineas se definen los movimientos que realizará la
##camara.
self.keyMap[key] = value
def move(self, task):

base.camera.lookAt(self.ralph)
if (self.keyMap["cam-left"]!=0):
base.camera.setX(base.camera, -20 * globalClock.getDt())
if (self.keyMap["cam-right"]!=0):
base.camera.setX(base.camera, +20 * globalClock.getDt())
startpos = self.ralph.getPos()
self.floater.setPos(self.ralph.getPos())
self.floater.setZ(self.ralph.getZ() + 3.0)
base.camera.lookAt(self.floater)
return task.cont
w = World()
## En las siguientes lineas se cargaran, escalan y posicionan las letras que

apareceran en la pantalla, como el titulo del programa y las instrucciones de
los movimientos del actor.
from direct.gui.OnscreenText import OnscreenText

from pandac.PandaModules import *
def genLabelText(text, i):
return OnscreenText(text = text, pos = (-1.3, .95-.05*i), fg=(1,1,1,1),
align = TextNode.ALeft, scale = .05)
titulo = OnscreenText(text = "Panda3D: Manipulacion de Partes de un Actor",

style=1, fg=(1,1,1,1),
pos=(0.6,-0.95), scale = .07)
Etiqueta = genLabelText("ESC: Salir", 0)

Etiqueta = genLabelText("[1]: Mueve la mano derecha", 1)
Etiqueta = genLabelText("[2]: Mueve la mano izquierda", 2)
Etiqueta = genLabelText("[3]: Mueve la muneca derecha", 3)
Etiqueta = genLabelText("[4]: Mueve la muneca izquierda", 4)
Etiqueta = genLabelText("[6]: Mover Tobillo derecho", 5)
Etiqueta = genLabelText("[8]: Mover el brazo derecho", 6)
Etiqueta = genLabelText("[9]: Mover el brazo izquierdo", 7)
Etiqueta = genLabelText("[I]: Mover el codo izquierdo", 8)
Etiqueta = genLabelText("[C]: Movimiento de la pierna izquierda", 9)
Etiqueta = genLabelText("[R]: Movimiento de la rodilla izquierda", 10)
Etiqueta = genLabelText("[T]: Movimiento del tobillo izquierdo", 11)
Etiqueta = genLabelText("[Z]: Mueve el cuello", 12)
Etiqueta = genLabelText("[O]: Mueve el parpado izquierdo", 13)
Etiqueta = genLabelText("[P]: Mueve el parpado derecho", 14)
Etiqueta = genLabelText("[M]: Mueve la Mejilla derecha",15)
Etiqueta = genLabelText("[M]: Mueve la Mejilla izquierda",16)
Etiqueta = genLabelText("[B]: Mover la barbilla", 17)
Etiqueta = genLabelText("[L]: Meuve el labio superior", 18)
run()
68
Capítulo V. Resultados y Conclusiones
5.1. Resultados
Los resultados obtenidos durante la realización del proyecto de residencias consisten

en la terminación de la manipulación de las distintas partes del cuerpo, y observación
del movimiento de las mismas.
Además la finalización de los tutoriales que faciliten:
La creación de animaciones en tiempo real.

La importación de los modelos en formato “.egg” que puede ser leído en Panda
3D.
Programación en Python.
Manipulación de las distintas partes de un cuerpo.
5.2. Conclusiones
Las conclusiones a las cuales se llegaron durante el desarrollo de este proyecto son
que Panda 3D es un programa que es sencillo de aprender a manejar y que
proporciona muchas facilidades en el desarrollo de animaciones en 3D.
A la vez nos dimos cuenta que se puede simplificar la creación de animaciones

mediante la importación de animaciones previamente creados por otros programas,
como lo pudimos observar en nuestro caso al ejecutar animaciones en tiempo real que
vienen creados previamente.
El proyecto puede ser retomado más adelante para seguir desarrollando las
animaciones y buscarles un fin específico, es decir que no solo nos quedemos con las
animaciones y sus respectivas manipulaciones, sino que nos sirvan mas adelante para
el desarrollo de aplicaciones interactivas en un mundo virtual.
69
Bibliografía
[1] Baileson, J., Blascovich, J.: Avatars. Encyclopaedia of Human-Computer

Interaction, Berkshire Publishing Group (2004).
[2] http://www.alegsa.com.ar/Dic/modelo%20en%203d.php Definición de Modelos en

3d y creación y animación de imágenes. Diccionario Informático.
[3]Blanco Cobián, Álvaro. “Modelado 3D” abc.mitreum.net/wp-content/uploads/clase2-

parte1-teoria.pdf. Universidad de León.
[4] http://www.anim8or.com/main/index.html Welcome to Anim8or. Página Oficial del

Software. R. Steven Glanville 2008.
[5] http://es.wikipedia.org/wiki/Blender Definición de Blender, Wikipedia.
[6] http://www.alegsa.com.ar/Dic/animacion%203d.php Definición Animación 3d. .

Diccionario Informático.
[7]http://www.google.com.mx/search?hl=es&q=caracteristicas+motor+de+juego&meta=
Es el componente de software central de un video juego que maneja todos los
elementos.
[8] http://www.panda3d.org/wiki/index.php/Multi-Part_Actors. Manual de panda3D,

Modelos y actores.
[9] http://en.wikipedia.org/wiki/Panda3D. Panda3d Es un sistema 3D enfocado a la

creación de videojuegos en PC con una biblioteca de subrutinas que incluyen también
gráficos.
[10] http://docs.python.org/release/2.5.2/lib/node950.html Historia del Software. Python

Library Reference.
[11]http://www.ub.edu.ar/catedras/ingenieria/ing_software/ubftecwwwdfd/mids_web/prot
otyp/estrdes.htm Estrategia de Desarrollo por Prototipos. Metodología integral de
desarrollo de sistemas. Lic. Domingo F. Donadello. Universidad de Belgrano, Buenos
Aires-Argentina.
70

Creacion de Animaciones en Tiempo Real C

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Creacion de Animaciones en Tiempo Real C

Cargado por

Copyright:

Formatos disponibles

REPORTE FINAL DE RESIDENCIAS

Nombre del Proyecto: PROTOCOLO PARA LA CREACION DE ANIMACIONES EN

Empresa: Instituto Tecnológico de Cd. Madero.

Lugar: División de Estudios de Posgrado e Investigación.

Nombre del Asesor Externo: Dra. Ma. Lucila Morales Rodríguez

Puesto: Profesor Investigador

Correo Electrónico: lmoralesrdz@gmail.com

Periodo de Realización de Residencia: Febrero-Julio 2010

Inicio: 23 de Febrero del 2010 Fin: 01 de Julio del 2010

Horario de trabajo: Lunes a Viernes de 8:00 – 16:00 hrs.

Horas totales: 640 horas

Carrera: Ingeniería en Sistemas Computacionales

Correo Electrónico: ing.ivan_palomera@hotmail.com

Carrera: Ingeniería en Sistemas Computacionales

Correo Electrónico: markhr_06@hotmail.com

Capítulo II. Marco Teórico............................................................................................................. 9

Capítulo III. Descripción del Proyecto....................................................................................... 19

Capítulo IV. Desarrollo del Proyecto ........................................................................................ 23

Capítulo V. Resultados y Conclusiones..................................................................................... 69

1.1 Instituto Tecnológico de Ciudad Madero

1.1.2. Maestría en Ciencias de la Computación

La Maestría en Ciencias en Ciencias de la Computación es un programa que depende

1.1.2.2. VISIÓN GENERAL

Que la Maestría en Ciencias en Ciencias de la Computación sea un programa

Formar especialistas en la Ciencia de la Computación con un alto nivel científico y

1.2 Información del Proyecto de Residencias

Actualmente en la Maestría en Ciencias en Ciencias de la Computación se está

1.3.1. Objetivo General

El objetivo de esta residencia es escribir un protocolo que se enfoque a la

1.3.2. Objetivos Específicos

Revisión de literatura sobre Animación y Modelado 3D.

1.4. Caracterización del Área

Las actividades que se realizan en el área de maestrías en ciencias de la computación

• Orienta sus capacidades y esfuerzos a formar especialistas en Ciencias de la

• Sustenta los conocimientos científicos y tecnológicos para atender la

• Forma grupos de investigación y desarrollo que contribuyen a satisfacer la

• La creación de un tutorial para facilitar la creación de animaciones en tiempo

• Identificación de propiedades y funciones que trabajan con huesos y

• Aprender a desarrollar funciones que animen las diferentes partes de un

1.6. Alcances y Limitaciones

El alcance que tendrá este proyecto es la creación de los tutoriales, donde se

La principal limitación que tendremos durante el desarrollo de esta práctica es:

• El motor de juego que se utilizara para la importación de los modelos será

A continuación se trataran algunos conceptos que se manejan dentro de la

2.2. Motor de Juego Panda 3D

Un motor de Juego es el componente de software central de un video juego que

PANDA 3D es un motor de juego que está formado de una biblioteca de subrutinas

2.3. Lenguaje de Programación

2.4.1. Sistema de coordenas

En el modelado el sistema de coordenadas es de mucha utilidad ya que permiten

Cuando realicemos una transformación a un objeto (entre otras operaciones), la

Figura 1: Ejemplo del sistema de coordenadas View (el establecido por

eje X: siempre hacia la derecha de la vista

La orientación de un cuerpo rígido puede especificarse completamente considerando

Dos sistemas ortogonales en el que se muestran los ángulos de Euler.

La definición matemática es estática y se basa en escoger dos planos, uno en el

o α es el ángulo entre el eje x y la línea de nodos.

Ángulos eulerianos o ángulos de navegación Yaw, pitch y Roll.

Yaw o guiñada: rotación con respecto al eje vertical o Y.

Estas rotaciones se muestran en las siguientes imágenes:

Es un "mundo conceptual en tres dimensiones" una representación esquemática

Este conjunto de características suele estar formado por objetos poligonales,

2.5.1. Herramientas de modelado