desarrollo de videojuegos 3d con software libre · 2.7 detección de colisiones 47 2.8 audio 2d y...
TRANSCRIPT
DESARROLLO DE VIDEOJUEGOS 3DCON SOFTWARE LIBRE
FACULTAD DE INGENIERÍA DE SISTEMAS,
INFORMÁTICA Y CIENCIAS DE LA
QUETZALTENANGO, NOVIEMBRE 2008
DESARROLLO DE VIDEOJUEGOS 3DCON SOFTWARE LIBRE
FACULTAD DE INGENIERÍA DE SISTEMAS,
INFORMÁTICA Y CIENCIAS DE LA
COMPUTACIÓN
QUETZALTENANGO, NOVIEMBRE 2008
DESARROLLO DE VIDEOJUEGOS 3D CON SOFTWARE LIBRE
FACULTAD DE INGENIERÍA DE SISTEMAS,
INFORMÁTICA Y CIENCIAS DE LA
QUETZALTENANGO, NOVIEMBRE 2008
http://cristiandlr.blogspot.com
Cristian de Léon Ronquillo
i
ii
Este proyecto de carrera fue elaborado por el estudiante Cristian Rafael de León Ronquillo como requisito establecido por la Facultad de Ingeniería de la Universidad Mesoamericana de Quetzaltenango, previo a obtener el título de Ingeniero de Sistemas, Informática y Ciencias de la Computación.
Quetzaltenango, noviembre de 2008.
iii
iv
ÍNDICE Introducción 1 Propuesta de proyecto 3 Objetivo general 5 Objetivos específicos 5 Capítulo I – Álgebra lineal 7
1.1 Antecedentes 9 1.2 Introducción 10 1.3 Vectores 10 1.4 Transformaciones lineales 17
Capítulo II – Irrlicht 3D Engine 25 2.1 Introducción 26 2.2 Características 26 2.3 Configurando el IDE (vs2005) y un ejemplo básico 27 2.4 Cargar mapas de Quake 3 y agregar una cámara FPS 33 2.5 Manejo de eventos y movimiento 37 2.6 Graphical User Inrface (GUI) 42 2.7 Detección de colisiones 47 2.8 Audio 2D y 3D con irrKlang 53 2.9 irrXML 59
Capítulo III – RakNet 61 3.1 Introducción 63 3.2 Características 63 3.3 Incluir RakNet en un proyecto 64 3.4 Comunicación básica: envío de cadenas 65 3.5 Irrlicht y RakNet, envío de estructuras 71
Capítulo IV – Aplicación: irrArena 81 4.1 Introducción 83 4.2 Características del juego 83 4.3 Instalación del juego 84 4.4 Diseño del juego 91
Conclusiones 95 Glosario 97 Bibliografía 101 Apéndice A – Licencia de Irrlicht Engine 103 Apéndice B – Contribuciones y recursos 105 Apéndice C – Contenido del CD 107
v
1
INTRODUCCIÓN Los videojuegos representan en la actualidad una de las industrias más
grandes del mundo y su popularidad ha venido creciendo de forma paralela a los avances informáticos y tecnológicos con los que se cuentan hoy en día.
El presente proyecto de investigación consta de dos partes: Una introducción teórica a los videojuegos 3D y el desarrollo de un videojuego de primera persona. Se inicia desde las bases matemáticas necesarias para trabajar con espacios tridimensionales hasta el uso del Engine de juegos Irrlicht 3D, la API de sonido 3D IrrKlang y la librería de funciones de red RakNet.
Con este proyecto de investigación se pretende aportar conocimiento a los estudiantes de ingeniería de sistemas o desarrolladores de software interesados en introducirse al mundo de la programación de videojuegos 3D con software libre.
La metodología utilizada para llevar a cabo el presente proyecto es la investigación. Antes de elaborarlo se consultaron diversas fuentes de información relacionadas al tema; se evaluaron características de diversos Engines de videojuegos, tales como Ogre 3D, Blitz3D e Irrlicht 3D; finalmente se tomó la decisión de utilizar Irrlicht 3D por las características que incorpora, la buena estructuración de la API y la amplia documentación con la que cuenta.
El presente documento consta de cuatro capítulos, los primeros tres corresponden a la parte teórica del proyecto y cubren los temas de espacios tridimensionales y àlgebra lineal, introducción al Engine Irrlicht 3D, utilización de la API de audio 2D y 3D Irrklang, acceso a archivos de configuración XML por medio de la librería irrXML y utilización de elementos de red por medio de RakNet. La parte demostrativa se detalla en el capítulo cuatro, corresponde al desarrollo de un videojuego de primera persona en red: “irrArena” se abarca no sólo el diseño del mismo, sino también su implementación, utilizando toda la teoría de la primera parte de la investigación.
Se espera que este proyecto sea de utilidad a los lectores y que sirva como material de apoyo para futuras investigaciones o proyectos de videojuegos.
2
3
PROPUESTA DE PROYECTO
El presente proyecto presenta una investigación sobre algunas tecnologías libres existentes que permiten desarrollar videojuegos 3D, además incluye temas generales acerca de los fundamentos matemáticos de los espacios tridimensionales (Álgebra linal), Irrlicht3D Engine, Manejo de Red con Raknet, acceso a archivos XML por medio de IrrXML, Audio 2D y 3D con IrrKlang y del desarrollo del videojuego de primera persona “irrArena”, aplicando el software antes mencionado.
Se compone de cuatro capítulos que explican de forma general y secuencial
los fundamentos utilizados para crear un videojuego 3D. Se asume que el lector tiene conocimientos de álgebra y programación, específicamente del lenguaje C++. Los primeros tres capítulos aportan la base teórica y el cuarto capítulo describe el juego irrArena que se incluye en el CD que acompaña a este documento.
El capítulo I presenta una introducción a las Matemáticas de los
videojuegos. Se tratan temas como sistemas lineales, vectores, interpretación geométrica de las operaciones vectoriales, proyecciones y transformaciones lineales.
El capítulo II incluye documentación y ejemplos del Engine Irrlicht 3D,
cubriendo temas que van desde el manejador de video, el entorno GUI, manejo de escena, carga de mapas de Quake 3, intercepción de eventos del teclado y del ratón (movimiento), colisiones, iluminación de escena, sonido 2D y 3D con irrKlang y carga de archivos XML con irrXML.
En el capítulo III se presenta una introducción a la librería de funciones de
Red RakNet, la cual ha sido diseñada específicamente para videojuegos. Se incluyen algunos ejemplos de comunicación de red, tales como el envío de cadenas y una pequeña aplicación que ilustra cómo envíar estructuras de datos genéricos y cómo combinar esta librería con Irrlicht.
El capítulo IV es la parte demostrativa del texto. Se desarrolla el videojuego “irrArena”, de primera persona, multijugador, para ello se utiliza Irrlicht3D y Raknet, presentando la documentación correspondiente y el diseño del mismo.
4
5
OBJETIVOS
General
Presentar una investigación que sirva como un aporte de conocimiento y
documentación a los estudiantes de ingeniería y desarrolladores de software
interesados en incursionar en mundo de los videojuegos 3D, particularmente con
software libre, planteando el presente proyecto de forma demostrativa y práctica.
Específicos
1. Investigar las características y el funcionamiento básico de un Engine de
gráficos 3D de tiempo real y aplicar este conocimiento para desarrollar un
juego de video.
2. Presentar una introducción a la librería de funciones de red RakNet para
programar juegos y aplicaciones de red en general.
3. Diseñar y desarrollar el juego de acción “irrArena” para aplicar y exponer el
conocimiento adquirido durante la elaboración de este proyecto.
6
ÁLGEBRA LINEAL
El álgebra lineal
estudia conceptos, tales como vectores, matrices, sistemas de
ecuaciones lineales y
vectoriales y transformaciones lineales. En ésta figura se
muestra un cubo al que se aplicaron di
de rotación.
7
CAPÍTULO I
ÁLGEBRA LINEAL
álgebra lineal es la rama de las matemáticas que
estudia conceptos, tales como vectores, matrices, sistemas de
ecuaciones lineales y - en un enfoque más formal - espacios
vectoriales y transformaciones lineales. En ésta figura se
muestra un cubo al que se aplicaron diversas transformaciones
es la rama de las matemáticas que
estudia conceptos, tales como vectores, matrices, sistemas de
espacios
vectoriales y transformaciones lineales. En ésta figura se
versas transformaciones
8
9
1.1 Antecedentes
Un videojuego es un programa informático, creado para el entretenimiento, basado en la interacción entre una o varias personas y un aparato electrónico (ya sea un ordenador, un sistema arcade, una videoconsola o un dispositivo handheld), el cual lo ejecuta. En muchos casos, los videojuegos recrean entornos y situaciones virtuales en los cuales el jugador puede controlar a uno o varios personajes (o cualquier otro elemento), para conseguir ciertos objetivos por medio de reglas determinadas.
La popularidad de los videojuegos ha venido aumentando con gran rapidez
en las últimas décadas, tanto que su industria representó un valor de 41.9 billones de dólares mundialmente durante el año 2007. Se estima que para 2012 generará unos 68.3 billones de Dólares1, superando así a la industria cinematográfica.
En el año de 1961 fue desarrollado Spacewar! – considerado el primer videojuego para computadora – y a partir de esa fecha, la tecnología y la informática han evolucionado para ofrecer nuevas alternativas que mejoran la experiencia del jugador, mostrando entornos más reales. La introducción de Mortal Kombat – un producto que utilizaba Sprites – presentó un avance considerable en la calidad gráfica de los videojuegos. Al operar en dos dimensiones, éste permite manejar un mayor detalle en las animaciones, así como añadir efectos visuales que simulan profundidad, debido a que están basados en mapas de bits dibujados en la pantalla del ordenador. Más adelante, con el videojuego Quake, se introdujeron modelos tridimensionales para los personajes en lugar de utilizar Sprites. En este caso la animación es realizada por medio de bones (huesos virtuales).
En la década de 1990 se introdujo el término “Game Engine”, el cual hace referencia a una plataforma que permite manejar los aspectos que son comunes a todos los videojuegos (código reutilizable). Éstos pueden ser: código reutilizable, carga de objetos, visualización y animación de modelos, detección de colisiones entre objetos, física, dispositivos de control como: el teclado, mouse, joystick, etc., interfaces gráficas de usuario e incluso parte de la inteligencia artificial del juego.
1 Study: Video Games on Winning Streak, PC Magazine.
http://www.pcmag.com/article2/0,1759,2320607,00.asp
10
1.2 Introducción La Física es una disciplina muy extensa, abarca desde el movimiento simple de un cuerpo, el comportamiento de las ondas mecánicas como el sonido, el comportamiento de la luz y demás ondas electromagnéticas, hasta temas más avanzados como Relatividad y Física Cuántica. Algunos temas de Física son útiles en el desarrollo de videojuegos, por ejemplo, se podría utilizar la óptica para simular la forma en la que la luz viaja e incide sobre los objetos para generar gráficas de alta calidad (Ray-tracing), pero cuando se habla de la Física de los videojuegos se refiere a la mecánica clásica, que consiste en describir el movimiento de sistemas de partículas físicas, de sistemas macroscópicos y a velocidades pequeñas comparadas con la velocidad de la luz. En un videojuego, la mecánica clásica se utiliza para dar a los objetos la sensación de ser sólidos, tener masa, inercia, rebote y cierto grado de capacidad para flotar. Toda la parte física es controlada por el Engine o motor de gráficos 3D, por tanto en este capítulo se hará referencia a conceptos fundamentales del Álgebra lineal, como una introducción a los sistemas lineales, vectores y tranformaciones en el espacio. 1.3 Vectores 1.3.1 SISTEMA LINEAL Muchos problemas pueden modelarse y resolverse por medio de un sistema lineal. Éste consiste en un conjunto de m ecuaciones con n variables (o incógnitas), es decir, un conjunto de m ecuaciones lineales. Las leyes de la mecánica se modelan mediante sistemas lineales. Particularmente interesan los sistemas de tres variables (véase la figura 1.1), donde se puede representar, por ejemplo, la posición en el espacio relativa a un origen de una partícula, mediante las distancias x, y y z trazadas ortogonalmente (a 90o) entre sí.
11
1.3.2 VECTORES Algunas medidas físicas como la temperatura, el área, la masa, el volumen y la energía pueden ser representadas simplemente como una magnitud, un número real conocido en álgebra escalar. Sin embargo, cuando se necesita indicar la dirección (además de la magnitud), se utiliza un vector, el cual se define como una magnitud física con dirección y sentido. Por medio de vectores se puede modelar una fuerza, un desplazamiento, una velocidad, una aceleración, etc. Los vectores son objetos algebraicos y geométricos. Este tipo de dualidad permite estudiar la geometría con métodos algebraicos. Un vector es una matriz columna de n x 1 o n-vector, por ejemplo:
1,
2u
=
2
4 ,
6
v
=
0.5
2
3
1
w
− − = −
Los anteriores son vectores 2, 3 y 4 (en 2R , 3R y 4R ) respectivamente. Los elementos de un vector se llaman componentes . 1.3.3 MÓDULO DE UN VECTOR El módulo de un vector es su magnitud y se define de la siguiente manera:
2 2 2
1 2 ... nv x x x= + + + , donde
1
2
...
n
x
xv
x
=
.
Figura 1.1. Imagen ilustrativa de la posición de una partícula en el espacio respecto al
origen. Las flechas que están sobre los ejes representan variables de posición de un sistema
lineal de 3 variables (x, y y z) que combinadas denotan la posición de dicha partícula.
12
En la figura 1.2 se aprecia el significado geométrico de la magnitud de un vector.
1.3.4 DIRECCIÓN DE UN VECTOR
En 2R la dirección de un vector (véase la figura 1.3) está representada por el
ángulo entre el eje x positivo y el vector mismo, mientras que en 3R la dirección se representa mediante un vector unitario u llamado dirección de v.
El vector unitario u se define de la siguiente manera:
v
vu
v=
Éste tiene la propiedad de tener magnitud 1 y la misma dirección de v. Existen tres
vectores unitarios que se usan como base para generar todo el espacio 3R , estos son:
i, j y k
y se definen de la siguiente manera:
Figura 1.2. Esta imagen muestra la interpretación geométrica del modulo
de un vector, esto es su magnitud desde el origen, denotada por v .
Figura 1.3. El ángulo θ entre el vector v y el eje x
representa la dirección del vector v en 2R .
13
1
i 0
0
=
,
0
j 1
0
=
y
0
k 0
1
=
De manera que se puede escribir cualquier otro vector en 3R como una combinación lineal de estos vectores, por ejemplo:
3
2 3i 2 j;
0
v
= − = −
Otra forma de representar la dirección de un vector en 3R es mediante sus ángulos directores, tal como se aprecia en la figura 1.4.
1.3.5 OPERACIONES VECTORIALES Y SU INTERPRETACIÓN GEOMÉTRI CA 1.3.5.a Suma vectorial
La suma de vectores consiste en sumar las componentes de los mismos, es decir, la suma de las componentes x será la componente x del vector resultante, y de esta misma manera las componentes y, z, …, se suman para formar las componentes y, z, … del vector resultante, por ejemplo:
Sea u = 3i – j, y v = –i +2j – 2k. Hallar u + v
u + v = (3 –1)i + (–1 +2)j + (–2)k = 2i + j – 2k;
Gráficamente esto es equivalente a colocar, sin importar el orden, (propiedad conmutativa de la suma) el origen de cada vector al final de otro vector, el vector resultante es aquél que se dirige desde el origen del primer vector hasta el final del último, como se aprecia en la figura 1.5.
Figura 1.4. Los ángulos directores son los que van
desde un eje hasta el vector v y definen la dirección del
mismo.
1.3.5.b Resta vectorial Para restar vectores algebraicamente se cambian los signos del vector a restar (sustraendo) y luego se suman ambos vectores.
Sea u = 2i – 3j + k, y
u – v = 2i – 3j + k –
Al restar dos vectores se obtiene un tercer vector dirigidovector sustraendo hasta el extremo del vector minuendo, como se ve en la
1.3.5.c Producto de un escalar por un vector Para obtener el producto de escalar por cada uno de los componentes del vector.disminución) proporcional al escalar en la magnitud del vector. V
Figura 1.5.
representa la suma de los vectores u, v y w.
Figura 1.6
vector v – u
14
Para restar vectores algebraicamente se cambian los signos del vector a restar (sustraendo) y luego se suman ambos vectores.
, y v = 2i +j – k. Hallar u – v
– (2i +j – k) = –4j;
Al restar dos vectores se obtiene un tercer vector dirigido desde el extremo del vector sustraendo hasta el extremo del vector minuendo, como se ve en la
de un escalar por un vector
obtener el producto de un vector por un escalar, simplementeescalar por cada uno de los componentes del vector. Esto provoca un aumento (o disminución) proporcional al escalar en la magnitud del vector. Véase la
. (a) Tres vectores en el espacio (u, v y w). (b) El vector R
la suma de los vectores u, v y w.
6. Interpretación geométrica de la resta de vectores. El
u se dirige desde el extremo de u hasta el extremo de
Para restar vectores algebraicamente se cambian los signos del vector a restar
desde el extremo del vector sustraendo hasta el extremo del vector minuendo, como se ve en la figura 1.6.
un vector por un escalar, simplemente se multiplica el Esto provoca un aumento (o
la figura 1.7.
(b) El vector R
Interpretación geométrica de la resta de vectores. El
hasta el extremo de v.
Cuando ambos factores en el producto son vectores, de producto: uno que genere un escalarproducto interior o producto punto)llamado producto vectorial (también llamado 1.3.5.d Producto escalar
Sean
1
2a
...
n
a
a
a
=
y b
denotado por a b⋅ está dado por:
Ambos vectores deben tener el mismo número de elementos.
Geométricamente se puedeEl producto (escalar) de dos vectores no nulos es igual al módulo de uno de ellos por la proyección del otro sobre él. La proyección (véase la fde cero) se define de la siguiente manera
Figura 1.
multiplicado por el escalar
15
ambos factores en el producto son vectores, se puedenuno que genere un escalar, llamado producto escalar (
producto interior o producto punto) o bien un producto que genere un nuevo vector, llamado producto vectorial (también llamado producto exterior o producto cruz).
1
2b
...
n
b
b
b
=
dos vectores, entonces el producto escalar de
está dado por:
1 1 2 2a b ... n na b a b a b⋅ = + + +
deben tener el mismo número de elementos.
se puede interpretar el producto escalar de la siguiente manera:El producto (escalar) de dos vectores no nulos es igual al módulo de uno de ellos por la proyección del otro sobre él.
véase la figura 1.8.) de un vector u sobre otro vector siguiente manera:
2proyv
u vu v
v
⋅=
Figura 1.7. (a) Un vector u en el espacio. (b) El vector u
multiplicado por el escalar c.
se pueden realizar dos tipos producto escalar (también llamado
genere un nuevo vector, producto exterior o producto cruz).
ntonces el producto escalar de a y b ,
interpretar el producto escalar de la siguiente manera: El producto (escalar) de dos vectores no nulos es igual al módulo de uno de ellos por la
sobre otro vector v (diferentes
16
1.3.5.e Producto vectorial
Sean u y v dos vectores tales que, 1
2
3
a
u a
a
=
y 1
2
3
b
v b
b
=
el producto cruz entre
ambos está definido por la determinante de la matriz 1 2 3
1 2 3
i j k
a a a
b b b
, de forma que:
1 2 3 2 3 3 2 1 3 3 1 1 2 2 1
1 2 3
i j k
( )i ( ) j ( )k;u v a a a a b a b a b a b a b a b
b b b
× = = − − − + −
Donde i , j y k son los vectores unitarios (bases de 3R ).
El producto cruz está definido únicamente para 3R y gráficamente u v× es un vector ortogonal, tanto a u como a v (vector normal n ). Hay dos vectores que son ortogonales, tanto a u como a v : u v× y v u× ; la dirección del vector u v× se determina por medio de la regla de la mano derecha 2. Si se coloca la mano derecha de manera que el índice apunte en la dirección de u y el dedo medio en la dirección de v , entonces el pulgar apuntará en la dirección de u v× . Véase la figura 1.9.
2 Algebra lineal. Stanley I. Grossman. El producto cruz de dos vectores, pág. 263. Editorial McGraw-Hill, 1996.
Figura 1.8. (a) proyvu cuando el ánguloθ entre ambos vectores (u
y v) es menor que 2π . (b) proyvu cuando el ánguloθ entre ambos
vectores (u y v) es mayor que 2π .
17
Algunas propiedades importantes del producto cruz se enuncian a continuación:
Sean u , v y w tres vectores en 3R y sea a un escalar cualquiera, entonces: • 0 0 0.u u× = × = • ( ).u v v u× = − × (Propiedad anticonmutativa)
• ( ) ( ).au v a u v× = ×
• ( ) ( ) ( ).u v w u v u w× + = × + × (Propiedad distributiva)
• ( ) ( ).u v w u v w× ⋅ = ⋅ × (Triple producto escalar)
• ( ) ( ) 0.u u v v u v⋅ × = ⋅ × = (u v× es ortogonal a u y a v ) 1.4 Transformaciones lineales En los gráficos computacionales, las transformaciones lineales sirven para dar la sensación de movimiento en tiempo real a un determinado objeto en el espacio, se puede por ejemplo, cambiar la posición del objeto (traslación), rotar el objeto en torno a un eje, aumentar o disminuir su tamaño (escalar el objeto), sesgar el objeto o bien realizar cualquier combinación de lo anterior, simultáneamente.
Una transformación 3 T (también llamada mapeo o función) de un conjunto A a
un conjunto B , representada por :T A B→ , es una regla que asocia a cada elemento de
A un elemento b , único de B , llamado imagen de a bajo T . Se escribe ( )T a b= y se
dice que a se mapea a ( )T a . A se llama dominio de T . B es codominio de T . El
3 Definición de transformación: Algebra lineal con aplicaciones. Transformaciones lineales, pág. 307. George
Nakos y David Joyner. Editorial Thomson, 1999.
Figura 1.9. La dirección de u v× se puede
determinar usando regla de la mano derecha.
Figura 1.10. Transformación de una imagen.
18
subconjunto de B formado por todas las imágenes de los elementos de A se llama
rango o contradominio de T y se representa por R( )T .
Una transformación se llama lineal cuando cumple con las siguientes características: Sean u y v dos vectores y a un escalar, entonces
• ( ) ( ) ( ).T u v T u T v+ = +
• ( ) ( ).T cu cT u=
Se puede transformar cualquier punto (un vector en 3R ) en otro, usando una
matriz de transformación (de 4×4 para 3R , esto es necesario por la transformación de traslación que verá más adelante). Se usan matrices porque permiten modificar cada componente en un vector respecto de los tres ejes del espacio. En el siguiente ejemplo, una matriz reinterpreta el punto (x, y, z), produciendo el nuevo punto (x', y', z'): Simplemente se multiplica el vector (punto a transformar)
[ ]1v x y z=
por la matriz de transformación
11 12 13 14
21 22 23 24
31 32 33 34
41 42 43 44
M
M M M M
M M M M
M M M M
M M M M
=
así:
[ ] [ ]11 12 13 14
21 22 23 24
31 32 33 34
41 42 43 44
' ' ' 1 1
M M M M
M M M Mx y z x y z
M M M M
M M M M
=
De forma que:
11 21 31 41
12 22 32 42
13 23 33 43
' 1 ,
' 1 ,
' 1 .
x xM yM zM M
y xM yM zM M
x xM yM zM M
= + + += + + += + + +
Se pueden combinar las matrices de transformación en una matriz simple para calcular varias transformaciones en una sola operación (esta operación es conocida como
19
concatenación ). Esto se consigue multiplicando las matrices individuales de transformación (Véase la definición de Skeletal Animation en el glosario). 1.3.1 EJEMPLOS DE TRANSFORMACIONES LINEALES COMUNES A continuación se examinará brevemente algunas matrices de transformación. 1.3.1.a Escalado
Para cambiar el tamaño de un objeto en 3R se aplica la siguiente transformación (tal como se indicó anteriormente) a cada uno de los vértices que lo conforman:
0 0 0
0 0 0
0 0 0
0 0 0 1
x
y
z
s
s
s
Donde xs , ys y
zs son números reales que determinan las escalas de los ejes x, y
y z respectivamente. Por ejemplo, si se desea duplicar el tamaño de un triángulo cuyos vértices son
[ ]0 0 0 , [ ]1 1 0 y [ ]2 0 0 basta con multiplicar cada uno de estos vectores por la
matriz de transformación
2 0 0 0
0 2 0 0
0 0 2 0
0 0 0 1
para obtener los vértices del triángulo
transformado (véase la figura 1.11).
[ ] [ ]
2 0 0 0
0 2 0 00 0 0 1 [0 2 0 0 0 0 1 0 0 0 0 2 0 0 1 0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 1 1] 0 0 0 1
0 0 2 0
0 0 0 1
= ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ =
[ ] [ ]
2 0 0 0
0 2 0 01 1 0 1 [1 2 1 0 0 0 1 0 1 0 1 2 0 0 1 0 1 0 1 0 0 2 1 0 1 0 1 0 0 0 1 1] 2 2 0 1
0 0 2 0
0 0 0 1
= ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ =
[ ] [ ]
2 0 0 0
0 2 0 02 0 0 1 [2 2 0 0 0 0 1 0 2 0 0 2 0 0 1 0 2 0 0 0 0 2 1 0 2 0 0 0 0 0 1 1] 4 0 0 1
0 0 2 0
0 0 0 1
= ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ ⋅ + ⋅ + ⋅ + ⋅ =
1.3.1.b Rotación Se puede rotar un punto alrededor de un ejede rotación, una para cada eje, pueden combinarse (como ya se las matrices entre sí. Nota: Las matrices de rotaciónizquierda, como se aprecia en la f
La siguiente transformaciónnuevo punto (x', y', z'):
[ ' ' ' 1 1x y z x y z
Figura 1.1
resultado de
triángulo del inciso (a) por un factor de 2.
Figura 1.1
positiva del eje
sistema de mano derecha ocurre lo contrario, la dirección
positiva del eje
20
Se puede rotar un punto alrededor de un eje, para ello se cuenta con de rotación, una para cada eje, pueden combinarse (como ya se mencionó) multiplicando
Nota: Las matrices de rotación definidas aquí corresponden a un sistema de mano , como se aprecia en la figura 1.12.
La siguiente transformación rota el punto (x, y, z) sobre el eje x, produciendo un
] [ ]
1 0 0 0
0 cos sin 0' ' ' 1 1
0 sin cos 0
0 0 0 1
x y z x y zθ θθ θ
= −
Figura 1.11. (a) Un triángulo definido por sus vértices. (b) El
resultado de aplicar una transformación de tamaño al
triángulo del inciso (a) por un factor de 2.
Figura 1.12. En un sistema de mano izquierda, la dirección
positiva del eje z es la que se aleja del observador. En un
sistema de mano derecha ocurre lo contrario, la dirección
positiva del eje z es la que se acerca al observador.
se cuenta con tres matrices mencionó) multiplicando
corresponden a un sistema de mano
) sobre el eje x, produciendo un
1 0 0 0
0 cos sin 0
0 sin cos 0
0 0 0 1
21
La siguiente transformación rota el punto sobre el eje y:
[ ] [ ]
cos 0 sin 0
0 1 0 0' ' ' 1 1
sin 0 cos 0
0 0 0 1
x y z x y z
θ θ
θ θ
− =
La siguiente transformación rota el punto sobre el eje z:
[ ] [ ]
cos sin 0 0
sin cos 0 0' ' ' 1 1
0 0 1 0
0 0 0 1
x y z x y z
θ θθ θ
− =
Donde θ simboliza el ángulo de rotación en radianes. Los ángulos se miden en el sentido horario cuando se mira sobre el eje de rotación hacia el origen. 1.3.1.c Traslación La traslación permite –como su nombre lo indica– trasladar todos los vértices que conforman un objeto en el espacio a una nueva posición. El resultado de esta operación
es equivalente a sumar xT , yT y
zT a las coordenadas x , y y z , respectivamente,
obteniendo el vector 1x y zx T y T z T + + + . La siguiente transformación traslada el
punto (x, y, z) a un nuevo punto (x', y', z').
[ ] [ ]
1 0 0 0
0 1 0 0' ' ' 1 1
0 0 1 0
1x y z
x y z x y z
T T T
=
1.3.1.d Sesgado Esta transformación (también conocida como corte o deslizamiento) permite deslizar un punto a través de un eje determinado. La figura 1.10 es un ejemplo de transformación de corte relativo al eje x en 2D. Las figuras 1.13 y 1.14 muestran un cubo en el espacio que ha sido transformado, primero respecto al eje x (figura 1.13) y luego respecto al eje y (figura 1.14).
La siguiente transformación desliza el punto ((plano xy), produciendo un nuevo punto (
[ ' ' ' 1 1 1x y z x y z x cy y z
La siguiente transformación desliza el
[ ' ' ' 1 1 1x y z x y z x cx y z
En general, se puededeterminado y las transformaciones se pueden expresar como unamanera:
Deslizamiento en x, plano xy
Deslizamiento en y, plano xy
Deslizamiento en x, plano xz
Deslizamiento en z, plano xz
Figura 1.15.
deslizamiento en el eje
Figura 1.1
deslizamiento en el eje
22
La siguiente transformación desliza el punto (x, y, z) por un factor , produciendo un nuevo punto (x', y', z').
] [ ] [
1 0 0 0
1 0 0' ' ' 1 1 1
0 0 1 0
0 0 0 1
cx y z x y z x cy y z
= = +
La siguiente transformación desliza el un punto sobre el eje y (plano
] [ ] [
1 0 0
0 1 0 0' ' ' 1 1 1
0 0 1 0
0 0 0 1
c
x y z x y z x cx y z
= = +
se puede realizar un deslizamiento en cualquier eje utilizando un plano determinado y las transformaciones se pueden expresar como una función de la siguiente
xy: ( , , ) ( , , ).xS x y z x cy y z= +
xy: ( , , ) ( , , ).yS x y z x y cx z= +
xz: ( , , ) ( , , ).xS x y z x cz y z= +
xz: ( , , ) ( , , ).zS x y z x y z cx= +
Figura 1.15. La figura muestra el efecto que produce un
deslizamiento en el eje y (utilizando el plano xy).
Figura 1.13. La figura muestra el efecto que produce un
deslizamiento en el eje x (utilizando el plano xy).
) por un factor c en el eje x
]' ' ' 1 1 1x y z x y z x cy y z
(plano xy):
]' ' ' 1 1 1x y z x y z x cx y z
realizar un deslizamiento en cualquier eje utilizando un plano función de la siguiente
23
Deslizamiento en y, plano yz: ( , , ) ( , , ).yS x y z x y cz z= +
Deslizamiento en z, plano yz: ( , , ) ( , , ).zS x y z x y z cy= +
El factor c puede ser tanto positivo como negativo, esto se refleja en la dirección del eje sobre el que se realiza el deslizamiento.
24
25
Capítulo II
Irrlicht3D Engine
Indoor Rendering es una característica integrada en el
Engine que permite utilizar mapas de luz y superficies
curvas; adicionalmente existe un detector de colisiones
y un sistema de respuesta.
26
2.1 Introducción
Irrlicht3D es un motor de gráficos 3D de alto rendimiento y de código abierto escrito en C++ y utilizable tanto en C++ como en Lenguajes .NET. Es completamente independiente de la plataforma, utilizando Direct X, Open GL o su propio software de renderizado y tiene todas las características que pueden ser encontradas en otras plataformas 3D comerciales.
2.2 Características Irrlicht es un Engine 3D de tiempo real, multi-plataforma y de alto desempeño escrito en lenguaje C++. Es una poderosa API4 de alto nivel para la creación de completas aplicaciones 3D y 2D tal como juegos o aplicaciones para visualización científica. Viene con una excelente documentación e integra todas las características actualmente utilizadas para la representación visual como sombras dinámicas, sistemas de partículas, animación de personajes, tecnología interior y exterior (indoor and outdoor technology) y detección de colisiones.
Cabe mencionar que este software está actualmente en desarrollo. La información acerca de los avances en el desarrollo del proyecto está disponible en la siguiente página web:
http://irrlicht.sourceforge.net/development.html.
Sus principales características5 son:
• Renderizado 3D en tiempo real de alto desempeño utilizando Direct3D y OpenGL. • Independiente de la plataforma. Compatible con Windows 95, 98, NT, 2000, XP,
Vista, GNU/Linux, y MacOS. • Incorpora una enorme y extensible librería de materiales con soporte para Pixel
Shaders y Vertex Shaders. • Manejo de escenas altamente personalizable para interiores y exteriores. • Sistema de animación de modelos con esqueletos (Skeletal Animation) y animación
de vértices (Morph target animation). • Efectos de partículas, billboards, mapas de luz, mapeo de entorno, stencil buffer
shadows y muchos otros efectos especiales. • Bindings para .NET, lo que hace que el Engine esté disponible para cualquier
lenguaje de la plataforma .NET tal como C#, VisualBasic y Delphi.NET. • Incluye dos rápidos renderizadores por software independientes, tanto de la
plataforma como del driver de video que tienen diferentes propiedades: Corrección de texturas mapeadas en perspectiva, filtrado bilineal, corrección sub-píxel, z-buffer, Gouraud shading, alpha-blending y transparencias, dibujo 2D rápido y más.
4 API, del inglés: Aplication Programming Interface o Interfaz de programación de aplicaciones.
5 Fuente: Irrlicht3D Features, http://irrlicht.sourceforge.net/features.html
27
• Sistema de interfaz gráfica de usuario (GUI) personalizable y fácil de usar. Incluye botones de comando, listas, cajas de texto, etc.
• Funciones de dibujo en 2D: alpha blending, blitting, dibujo de fuentes y mezcla de gráficas 2D y 3D.
• Una API bien documentada y correctamente estructurada. • Escrito completamente en lenguaje C++ y totalmente orientado a objetos. • Funciones para lectura directa de los formatos más comunes de objetos 3D, entre
ellos: 3D Studio meshes (.3ds), B3D files (.b3d), Alias Wavefront Maya (.obj), Cartography shop 4 (.csm), COLLADA (.xml, .dae), DeleD (.dmf), FSRad oct (.oct), Irrlicht scenes (.irr), Irrlicht static meshes (.irrmesh), Microsoft DirectX (.x) (binary & text), Milkshape (.ms3d), My3DTools 3 (.my3D), OGRE meshes (.mesh), Pulsar LMTools (.lmts), Quake 3 levels (.bsp), Quake 2 models (.md2) y STL 3D files (.stl).
• Funciones de lectura directa de formatos de textura: Adobe Photoshop (.psd), JPEG File Interchange Format (.jpg), Portable Network Graphics (.png), Truevision Targa (.tga), Windows Bitmap (.bmp) y Zsoft Paintbrush (.pcx).
• Rápido sistema de detección de colisiones. • Librerías de contenedores de plantillas de funciones matemáticas 3D rápidas y
optimizadas. • Lectura directa de archivos comprimidos (.zip). • Parser (Analizador sintáctico) de archivos XML integrado (irrXML). • Soporte para Unicode. • Compatible con Microsoft VisualStudio6.0™, VisualStudio.NET 7.0-8.0™, Metrowerks
Codewarrior y Bloodshed Dev-C++ con g++3.2-4.0. • El Engine es de código abierto y completamente libre. Puede ser depurado, corregido
e incluso modificado sin la obligación de hacer públicos dichos cambios: El Engine está bajo los términos de la licencia zlib6.
2.3 Configurando el IDE (Visual Studio 2005) y un ejemplo básico
Como se ha descrito en la sección 1.2, Irrlicht puede ser incorporado en una amplia variedad de Entornos de Desarrollo Integrados (IDEs), siendo los pasos para la integración similares en los múltiples entornos de desarrollo. Aquí se describe cómo configurarlo con uno de los entornos de desarrollo más utilizados por los desarrolladores de software7; éste es el caso de Microsoft Visual Studio (actualmente puede obtenerse gratuitamente la versión Express en http://www.microsoft.com/Express/).
El SDK de Irrlicht puede obtenerse en http://irrlicht.sourceforge.net/downloads.html,
la versión actual es la 1.4.2 e incluye la documentación, tutoriales, exportadores y varios
6 Véase el Apéndice A. Licencia del Engine Irrlicht3D.
7 Texto Original - Tutorial 1: HelloWorld - http://irrlicht.sourceforge.net/tut001.html
28
programas de demostración, incluyendo el código fuente y archivos necesarios para correr todos los ejemplos que se detallan a continuación. 2.3.1 CONFIGURANDO EL IDE Para utilizar el Engine se debe incluir el archivo de cabecera irrlicht.h. Éste archivo se encuentra en el directorio include del SDK. Para permitir al compilador acceder a dicho archivo, se debe configurar la ruta al mismo. En Microsoft Visual Studio se debe realizar el siguiente procedimiento:
1. Seleccionar Opciones (Options) del menú de Herramientas (Tools) 2. Seleccionar la sección de Proyectos y Soluciones (Projects And Solutions) y
buscar la opción de Directorios de VC++ (VC++ Directories) como se vé en la Figura 2.2.
3. Seleccionar Include Files del combo que dice Mostrar directorios para (Show directories for) como se muestra en la Figura 2.3.
4. Agregar el directorio include con el botón . Dicho direcotrio se encuentra en la carpeta de instalación del SDK.
5. También es necesario agregar la librería irrlicht.lib, para ello se debe seleccionar la opción Archivos de Librería (Library files) del combo Mostrar directorios para (Show directories for) y agregar el directorio lib/VisualStudio incluído en el SDK.
Figura 2.2. Cuadro de opciones del menú Herramientas Visual Studio 2005.
Figura 2.3. Opción “Show directories for” del cuadro de opciones de Visual Studio 2005.
29
2.3.2 HOLA MUNDO! El siguiente programa ejemplifica los aspectos básicos del Driver de video, el entorno GUI, y el manejo de escena. Lo primero que se debe hacer es incluir el archivo de cabecera irrlicht.h
#include <irrlicht.h>
En el Engine Irrlicht todo se encuentra dentro del nombre de espacio irr. Para utilizar cualquiera de las clases del Engine se debe escribir irr:: antes del nombre de la clase. Por ejemplo, para acceder a la clase IrrlichtDevice, se debe escribir irr::IrrlichtDevice. Para evitar escribir irr:: antes de cada clase, se indica al compilador que se utilizará ese nombre de espacio de ahora en adelante y no habrá que escribir irr:: nuevamente. using namespace irr;
En el Engine Irrlicht hay cinco sub-espacios. Se puede encontrar información detallada de ellos en la documentación:
http://irrlicht.sourceforge.net/docu/namespaces.html De la misma forma en la que se declaró el nombre de espacio irr, se declara la utilización de estos cinco nombres de espacio para mantener este ejemplo fácil de entender. using namespace core; using namespace scene; using namespace video; using namespace io; using namespace gui;
Para poder utilizar el archivo Irrlicht.DLL, se debe vincular la aplicación con Irrlicht.lib. Ésta vinculación se puede establecer en las configuraciones del proyecto, pero para facilitar las cosas, se utilizará la instrucción pragma comment de Visual Studio. En plataformas Windows, se debe ocultar la ventana de consola, la cual salta cuando se inicia el programa en main(). Esto se hace con la segunda instrucción pragma. También se puede utilizar el método WinMain(), pero de esta manera la aplicación ya no es independiente de la plataforma (sistema operativo). #ifdef _IRR_WINDOWS_ #pragma comment(lib, "Irrlicht.lib") #pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup") #endif
30
Éste es el método main(), el cual es utilizado por cualquier plataforma.
int main() {
La función más importante del Engine es createDevice(). El Dispositivo Irrlicht es creado al llamarla. Éste es el objeto raíz para hacer cualquier cosa con el Engine. createDevice() tiene siete parámetros:
• deviceType: tipo de dispositivo. Puede ser un dispositivo nulo, D3D8, D3D9, OpenGL o bien alguno de los dos renderizadores de software incluídos en el Engine. En este ejemplo se usa el EDT_SOFTWARE, pero esto puede ser sustituido por EDT_BURNINGSVIDEO, EDT_NULL, EDT_DIRECT3D8, EDT_DIRECT3D9, o EDT_OPENGL, según el tipo de dispositivo que se requiera.
• windowSize: define el tamaño de la ventana, o bien, la resolución de la pantalla
cuando se está ejecutando en modo de pantalla completa. En este ejemplo se usa 640x480.
• bits: define la cantidad de bits de color por píxel, 16 ó 32. El parámetro es
generalmente ignorado cuando se ejecuta en modo de ventana.
• fullscreen: especifica si se va a ejecutar en pantalla completa o en modo de ventana.
• stencilbuffer: especifica si se va a utilizar stencil buffer (para dibujar sombras).
• vsync: especifica la activación o desactivación de vsync, esto solo es útil en el
modo de pantalla completa.
• eventReceiver: es un objeto para interceptar eventos. Por ahora no se utiliza, así que se establecrá su valor a 0.
Siempre se debe verificar el valor de retorno para determinar controladores no soportados, dimensiones no válidas, etc. IrrlichtDevice *device = #ifdef _IRR_OSX_PLATFORM_ createDevice(video::EDT_OPENGL, dimension2d<s32>(640, 480), 16, false, false, false, 0); #else createDevice(video::EDT_SOFTWARE, dimension2d<s32>(640, 480), 16, false, false, false, 0); #endif if (!device) return 1;
Ahora se establecerá el título de la ventana. Notese que hay una ‘L’ antes de la cadena. El Engine Irrlicht utiliza cadenas de caracteres anchos para desplegar texto.
31
device->setWindowCaption(L"Hello World! - Irrlicht Engine Demo");
Ahora se crea un puntero al driver de video, el manejador de escena y el entorno de interfaz gráfica de usuario, de esta forma no se tendrá que escribir siempre: device-
>getVideoDriver(), device->getSceneManager(), o device->getGUIEnvironment(). IVideoDriver* driver = device->getVideoDriver(); ISceneManager* smgr = device->getSceneManager(); IGUIEnvironment* guienv = device->getGUIEnvironment();
Se añade una etiqueta a la ventana con el texto Hello World, usando para ello el entorno GUI. El cuadro de texto estático es posicionado en (10, 10) como la esquina superior izquierda y (260, 22) como la esquina inferior derecha. guienv->addStaticText( L"Hello World! This is the Irrlicht Software renderer!", //cadena a desplegar rect<s32>(10,10,260,22), //dimensiones de la caja de texto true //borde de la caja de texto );
Para mostrar algo más interesante, se cargará y desplegará en la escena un modelo MD2. Únicamente se debe cargar la malla desde el manejador de escena con getMesh() y agreagar un nodo de escena para desplegar la malla con addAnimatedMeshSceneNode(). Es recomendable verificar el valor de retorno de getMesh() para asegurar que no haya ocurrido ningún problema al abrir el archivo. En lugar de escribir el nombre de archivo sydney.md2, es posible cargar un archivo de objeto de Maya (.obj), un mapa completo de Quake 3 (.bsp) o cualquier otro formato de archivo soportado por el Engine (véase el listado de características para más información al respecto, Sección 2.2). El modelo sydney.md2 fue diseñado por Brian Collins. IAnimatedMesh* mesh = smgr->getMesh("../../media/sydney.md2"); if (!mesh) return 1; IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh );
Se debe cargar un material a la malla para que se vea mucho mejor. También se desactivará la iluminación porque por ahora no se ha agregado ninguna luz dinámica, de otra forma el modelo se vería completamente negro. Luego se establece el frame loop o ciclo de animación al estado predefinido STAND y por último se aplica una textura a la malla. Sin ésta última la malla sería dibujada, utilizando únicamente un color. if (node) { node->setMaterialFlag(EMF_LIGHTING, false); //desactivar iluminación node->setMD2Animation(scene::EMAT_STAND); //frame loop node->setMaterialTexture( //Aplicar la textura a la malla node 0, //capa de la textura driver->getTexture("../../media/sydney.bmp") //archivo de la textura
32
); }
Para hacer la malla visible en la pantalla se agrega una cámara en el espacio 3D, en la posición (0, 30, -40). La cámara verá desde allí hasta la posición (0, 5, 0), que es aproximadamente el lugar donde se cargó el modelo MD2. smgr->addCameraSceneNode(0, vector3df(0,30,-40), vector3df(0,5,0));
El siguiente paso es configurar la escena y dibujar todo: Se ejecuta el dispositivo en un ciclo while(), hasta que el dispositivo no desee continuar. Esto podría ocurrir cuando el usuario cierra la ventana o presiona Alt + F4 (o cualquier otro comando que cierre la ventana). while(device->run()) {
Cualquier cosa puede ser dibujada entre una llamada a beginScene() y una a endScene(). La llamada a beginScene() limpia la pantalla con un color determinado y el buffer de profundidad (depth buffer) si así se requiere. Luego se deja al manejador de escena y al entorno GUI dibujar su contenido. Con una llamada a endScene() todo es desplegado en la pantalla. driver->beginScene(true, true, SColor(255,100,101,140)); smgr->drawAll(); guienv->drawAll(); driver->endScene(); }
Después que se ha terminado con el ciclo de renderizado, se debe eliminar el dispositivo Irrlicht creado previamente con createDevice(). En el Engine Irrlicht se deben eliminar todos los objetos que se hayan creado con algún método o función que inicie con create. El objeto será eliminado simplemente con una llamada al método ->drop(). Para más información véase el artículo irr::IReferenceCounted::drop() en la documentación del Enigne. device->drop(); return 0; }
Solo hace falta compilar y correr la aplicación. A continuación una muestra de la pantalla del programa en ejecución en la figura 2.4.
33
2.4 Cargar mapas de Quake 3 y agregar una cámara F PS En esta sección se explica como cargar desde el Engine un mapa del juego Quake 3, crear un nodo de escena para optimizar la velocidad de renderizado y cómo crear y utilizar una cámara controlada por el usuario (First Person Shooter Camera o Cámera FPS) Se inicia como en la sección anterior, incluyendo el archivo de cabecera del Engine y un archivo adicional, iostream, para permitir al usuario seleccionar desde la consola el driver que se va a utilizar. #include <irrlicht.h> #include <iostream>
Como ya se mencionó en el ejemplo de la sección anterior, en el Engine Irrlicht todo se encuentra dentro del nombre de espacio ‘irr’. Para evitar escribir irr:: antes del nombre de cada clase del Engine se indica al compilador que se utilizará ese nombre de espacio de aquí en adelante. Hay otros cinco nombres de espacio (subepacios) dentro del nombre de espacio irr, estos son: core, scene, video, io y gui. A diferencia del ejemplo anterior, no se declara la utilización de estos nombres de espacio para distinguir las clases contendidas dentro de cada uno de ellos. using namespace irr;
De nuevo, para poder utilizar el archivo Irrlicht.DLL, se debe vincular con el archivo Irrlicht.lib. Se utiliza una instrucción pragma comment lib:
#ifdef _MSC_VER #pragma comment(lib, "Irrlicht.lib") #endif
Figura 2.4. Una muestra de la aplicación de ejemplo ‘Hola Mundo’ ejecutándose.
34
De nuevo, se utiliza el método main() para iniciar (en lugar de WinMain()). int main() {
Ahora se crea el dispositivo con createDevice(). La diferencia ahora es que se consultará al usuario qué controlador desea utilizar. El dispositivo de software podría ser muy lento para dibujar un mapa enorme de Quake 3; para propósitos de prueba se hará de ésta una opción del menú. // Elegir manejador de video video::E_DRIVER_TYPE driverType; printf("Por favor elija un manejador de video para la aplicación:\n"\ " (a) Direct3D 9.0c\n"\ " (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\ " (d) Software Renderer\n"\ " (e) Burning's Software Renderer\n"\ " (f) NullDevice\n (otherKey) exit\n\n" ); char i; std::cin >> i; switch(i) { case 'a': driverType = video::EDT_DIRECT3D9;break; case 'b': driverType = video::EDT_DIRECT3D8;break; case 'c': driverType = video::EDT_OPENGL; break; case 'd': driverType = video::EDT_SOFTWARE; break; case 'e': driverType = video::EDT_BURNINGSVIDEO;break; case 'f': driverType = video::EDT_NULL; break; default: return 1; } // Crear el dispositivo o salir si hay una falla IrrlichtDevice *device = createDevice(driverType, core::dimension2d<s32>(640, 480)); if (device == 0) return 1; //No se pudo crear el dispositivo.
Se crea un puntero al manejador de video y otro para el manejador de escena, de esta manera no es necesario tener que llamar siempre a irr::IrrlichtDevice::getVideoDriver() y irr::IrrlichtDevice::getSceneManager().
video::IVideoDriver* driver = device->getVideoDriver(); scene::ISceneManager* smgr = device->getSceneManager();
Para desplegar el mapa de Quake 3 primero se debe cargar. Los mapas de Quake 3 están empaquetados dentro de archivos .pk3, los cuales no tienen ninguna diferencia con los archivos .zip. Así que se agrega el archivo .pk3 al sistema de archivos
35
irr::io::IFileSystem. Después de cargado, se puede leer cualquier archivo contenido dentro del .pk3 como si estuviera directamente almacenado en el disco. device->getFileSystem()->addZipFileArchive("../../media/map-20kdm2.pk3");
Ahora se puede cargar la malla llamando a irr::scene::ISceneManager::getMesh(). Dicho método devuelve un puntero irr::scene::IAnimatedMesh. Como Ud. probablemente sabe, los mapas de Quake 3 no son realmente animados, simplemente contienen una enorme cantidad de geometría con algunos materiales adjuntos, de ahí que IAnimatedMesh consiste en un único fotograma, así que se debe obtener el “primer fotograma” de la “animación”, el cual representa el nivel de Quake y se crea un nodo de escena de tipo OctTree, usando para ello irr::scene::ISceneManager::addOctTreeSceneNode(). El OctTree optimiza un poco la escena, tratando de dibujar únicamente la geometría que es visible a cada momento mientras se ejecuta la aplicación. Una alternativa a OctTree podría ser irr::scene::IMeshSceneNode, el cual siempre dibuja la geometría completa de la malla, aún cuando no es visible en la pantalla. Se puede probar a utilizar irr::scene::ISceneManager::addMeshSceneNode() en lugar de addOctTreeSceneNode() para comparar las primitivas dibujadas por el manejador de video. Para contar el número de primitivas dibujadas se puede hacer uso del método llamado irr::video::IVideoDriver::getPrimitiveCountDrawn(), contenido dentro de la clase irr::video::IVideoDriver. Note que la optimización que se obtiene con OctTree solo es útil cuando se están dibujando enormes mallas conformadas por una gran cantidad de geometría. scene::IAnimatedMesh* mesh = smgr->getMesh("20kdm2.bsp"); scene::ISceneNode* node = 0; if (mesh) node = smgr->addOctTreeSceneNode(mesh->getMesh(0), //fotograma 0 de la malla 0, //Nodo padre -1, //ID del nodo 128 //Cantidad mínima de polígonos por nodo );
El mapa que se utiliza en este ejemplo no fue modelado alrededor del origen (0,0,0), se debe transformar por medio de los métodos irr::scene::ISceneNode::setPosition(), irr::scene::ISceneNode::setRotation() e irr::scene::ISceneNode::setScale(). if (node) node->setPosition(core::vector3df(-1300,-144,-1249));
Ahora hace falta agregar una cámara que visualice el mapa. Por ahora se necesita una cámara controlada por el usuario. Hay varias cámaras disponibles en el Engine Irrlicht. Por ejemplo la cámara de Maya (MayaCamera) puede ser controlada como una cámara en Maya: rota cuando el botón izquierdo del ratón está presionado, acerca o aleja (Zoom) cuando ambos botones están presionados y traslada con el botón derecho
36
presionado. Para agregar una cámara de Maya se utiliza irr::scene::ISceneManager::
addCameraSceneNodeMaya(). Para este ejemplo se va a utilizar una cámara que se comporta como los juegos de primera persona (FPS game o First Person Shooter game) y para ello se debe utilizar el método irr::scene::ISceneManager::addCameraSceneNodeFPS(). smgr->addCameraSceneNodeFPS();
El puntero del ratón debería ser invisible al usuario, para ello se establece la visibilidad a false por medio del método irr::IrrlichtDevice::ICursorControl. device->getCursorControl()->setVisible(false);
Ahora que se tiene la escena casi lista, solo resta dibujarla. Se desplegará la cantidad de fotogramas por segundo (fps) y la cantidad de primitivas dibujadas en la barra de título de la ventana. La verificación de irr::IrrlichtDevice::isWindowActive() es opcional, pero previene al Engine de seguir al puntero del mouse en la escena cuando se cambia a otra aplicación activa mientras el programa sigue en ejecución. La llamada a irr::IrrlichtDevice::yield() evitará que el ciclo principal del programa utilice todos los ciclos de la CPU cuando la ventana no está activa. int lastFPS = -1; while(device->run()) { if (device->isWindowActive()) { //la ventana está activa driver->beginScene(true, true, video::SColor(255,200,200,200)); smgr->drawAll(); driver->endScene(); int fps = driver->getFPS(); if (lastFPS != fps) { core::stringw str = L"Irrlicht Engine - Quake 3 Map example ["; str += driver->getName(); str += "] fotogramas/segundo:"; str += fps; device->setWindowCaption(str.c_str()); lastFPS = fps; } } else { //la ventana no está activa device->yield(); } }
Por último, se elimina el dispositivo Irrlicht.
device->drop(); return 0; }
Eso es todo. Luego de compilar y ejecutar la aplicación se verá como se muestra en la figura 2.5.
2.5 Manejo de e ventos y movimient En esta sección se describe para ello Animators (SceneNodeAnimators). También nodos utilizando el teclado por medio de un
Como siempre, se incluyen vínculo con el archivo Irrlicht
#include <irrlicht.h> #include <iostream> using namespace irr; #ifdef _MSC_VER #pragma comment(lib, "Irrlicht.lib")#endif
Para recibir los eventoscuando se ha presionado un botón de comando) se necesita clase irr::IEventReceiver. Hay solo un método que irr::IEventReceiver::OnEvent(). evento ocurra. Lo que realmente
Figura 2.5. Una pantalla del mapa de Quake 3
Irrlicht.
37
Luego de compilar y ejecutar la aplicación se verá como se muestra en la
ventos y movimient o
sta sección se describe cómo mover y animar nodos de para ello Animators (SceneNodeAnimators). También se realizará movimiento manual de nodos utilizando el teclado por medio de un objeto recibidor de eventos.
se incluyen los archivos de cabecera, el nombre de espacio Irrlicht.lib.
#pragma comment(lib, "Irrlicht.lib")
eventos de teclado, mouse y de interfaz de usuario (por ejemplo presionado un botón de comando) se necesita un objeto que
irr::IEventReceiver. Hay solo un método que se debeirr::IEventReceiver::OnEvent(). Este método será llamado por el Engineevento ocurra. Lo que realmente se debe saber es si una tecla está siendo presionada,
a pantalla del mapa de Quake 3 Return to Castle corriendo desde el Engine
Luego de compilar y ejecutar la aplicación se verá como se muestra en la
odos de escena, utilizando movimiento manual de
recibidor de eventos.
los archivos de cabecera, el nombre de espacio irr y un
de interfaz de usuario (por ejemplo un objeto que se derive de la
se debe sobrescribir: Engine cada vez que un
na tecla está siendo presionada,
corriendo desde el Engine
38
entonces se puede verificar el estado actual de cada tecla para saber de que tecla se trata. class MyEventReceiver : public IEventReceiver { // Se utiliza éste arreglo para verificar el estado de cada tecla bool KeyIsDown[KEY_KEY_CODES_COUNT]; public: // Este es el método que se debe implementar virtual bool OnEvent(const SEvent& event) { // Verificar si una tecla está siendo presionada if (event.EventType == irr::EET_KEY_INPUT_EVENT) KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown; return false; } // Ésta es utilizada para verificar si la tecla está siendo presionada virtual bool IsKeyDown(EKEY_CODE keyCode) const { return KeyIsDown[keyCode]; } MyEventReceiver() { for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i) KeyIsDown[i] = false; } };
El manejador de eventos para almacenar el estado de las teclas está listo, la respuesta a cada uno de estos eventos será realizada dentro del ciclo principal de la aplicación, justo después de dibujar la escena. Ahora se debe crear el dispositivo y el nodo de escena que responderá a los eventos de teclado, es decir, cuando se presiona una tecla este nodo de escena se mueve en la pantalla. También se crearán otros nodos adicionales, con el fin de demostrar que hay otras maneras de animar un nodo de escena. int main() { // Permitir al usuario seleccionar el manejador de video video::E_DRIVER_TYPE driverType = video::EDT_DIRECT3D9; printf("Por favor seleccione un manejador de video:\n"\ " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\ " (d) Software Renderer\n (e) Burning's Software Renderer\n"\ " (f) NullDevice\n (otherKey) exit\n\n"); char i; std::cin >> i; switch(i) { case 'a': driverType = video::EDT_DIRECT3D9;break; case 'b': driverType = video::EDT_DIRECT3D8;break; case 'c': driverType = video::EDT_OPENGL; break; case 'd': driverType = video::EDT_SOFTWARE; break;
39
case 'e': driverType = video::EDT_BURNINGSVIDEO;break; case 'f': driverType = video::EDT_NULL; break; default: return 0; } // Crear dispositivo MyEventReceiver receiver; IrrlichtDevice* device = createDevice( driverType, core::dimension2d<s32>(640, 480), 16, //bits de color false, //fullscreen false, //stencil buffer false, //vsync &receiver //manejador de eventos ); if (device == 0) return 1; // No se pudo crear el dispositivo. video::IVideoDriver* driver = device->getVideoDriver(); scene::ISceneManager* smgr = device->getSceneManager();
Ahora se crea el nodo que será movido (una esfera) cuando las teclas 'W' y 'S' sean presionadas. La esfera forma parte de las primitivas geométricas incluidas en el Engine. Se traslada el nodo a la posición (0, 0, 30) y para hacerlo un poco más interesante, se le asigna una textura. También se desactivará la iluminación para cada modelo porque no hay ninguna luz dinámica en la escena (de otra forma los modelos se verían completamente negros). scene::ISceneNode * node = smgr->addSphereSceneNode(); if (node) { node->setPosition(core::vector3df(0,0,30)); node->setMaterialTexture(0, driver->getTexture("../../media/wall.bmp")); node->setMaterialFlag(video::EMF_LIGHTING, false); }
Ahora se creará otro nodo que se mueva por medio de un objeto animador (animator). Los nodos de escena de animación modifican a los nodos de escena y pueden ser atachados a cualquier nodo de escena, tal como un nodo de escena de malla, billboards, luces e incluso cámaras. Los nodos de animación no modifican únicamente la posición de un objeto, también puede por ejemplo, animar la textura de un nodo de escena. Ahora se creará un cubo y a éste se atacha el animator fly circle (volar en círculos), permitiendo a este nodo volar alrededor de la esfera. scene::ISceneNode* n = smgr->addCubeSceneNode(); if (n) { n->setMaterialTexture(0, driver->getTexture("../../media/t351sml.jpg")); n->setMaterialFlag(video::EMF_LIGHTING, false); scene::ISceneNodeAnimator* anim = smgr->createFlyCircleAnimator(
40
core::vector3df(0,0,30), //centro 20.0f //radio ); if (anim) { n->addAnimator(anim); anim->drop(); //liberar memoria } }
El último nodo de escena se agregará para mostrar las posibilidades de los animators sobre modelos MD2, ahora se usa el animator fly straight (volar en línea recta), éste permite realizar la animación del modelo corriendo entre dos puntos. scene::IAnimatedMeshSceneNode* anms = smgr->addAnimatedMeshSceneNode( smgr->getMesh("../../media/sydney.md2") ); if (anms) { scene::ISceneNodeAnimator* anim = smgr->createFlyStraightAnimator( core::vector3df(100,0,60), //origen core::vector3df(-100,0,60), //destino 2500, //tiempo de la animación true //loop ); if (anim) { anms->addAnimator(anim); anim->drop(); }
Para ver el modelo correctamente se desactiva la iluminación, también se establece el rango de fotogramas en el cual se realizará la animación del modelo, se rota 180 grados y se ajustan tanto la velocidad de animación como la textura. Para establecer la animación correcta, esto es: valores correctos de fotorgramas inicial y final y velocidad de la animación, se debe llamar a anms->setMD2Animation(scene::EMAT_RUN) para la animación de correr en lugar de llamar a setFrameLoop y setAnimationSpeed, pero ésto solo funciona con animaciones de modelos MD2. anms->setMaterialFlag(video::EMF_LIGHTING, false); anms->setFrameLoop(160, 183); anms->setAnimationSpeed(40); anms->setMD2Animation(scene::EMAT_RUN); anms->setRotation(core::vector3df(0,180.0f,0)); anms->setMaterialTexture(0, driver->getTexture("../../media/sydney.bmp")); }
Para poder ver y desplazarse en la escena, se agrega una cámara de tipo FPS y también es recomendable ocultar el puntero del mouse.
41
scene::ICameraSceneNode * cam = smgr->addCameraSceneNodeFPS(0, 100.0f, 100.0f); device->getCursorControl()->setVisible(false);
Agregar un logo de Irrlicht a todo color. device->getGUIEnvironment()->addImage( driver->getTexture("../../media/irrlichtlogoalpha2.tga"), //logo core::position2d<s32>(10,10) //posición );
Ahora la escena está lista, solo resta dibujar. También se desplegará la cantidad actual de fotogramas por segundo y el nombre del manejador de video en el título de la ventana.
int lastFPS = -1; while(device->run()) {
Se debe verificar si alguna de las teclas W o S está siendo presionada, y si esto ocurre la esfera se moverá hacia arriba o abajo respectivamente.
if(receiver.IsKeyDown(irr::KEY_KEY_W)) { core::vector3df v = node->getPosition(); v.Y += 0.02f; node->setPosition(v); } else if(receiver.IsKeyDown(irr::KEY_KEY_S)) { core::vector3df v = node->getPosition(); v.Y -= 0.02f; node->setPosition(v); } driver->beginScene( true, //backbuffer true, //z-buffer video::SColor( 255, //alfa 113, //rojo 113, //verde 133 //azul ) ); smgr->drawAll(); // Dibujar la escena 3D device->getGUIEnvironment()->drawAll(); // Dibujar el entorno GUI (El logo) driver->endScene(); int fps = driver->getFPS(); //frames per second if (lastFPS != fps) { core::stringw tmp(L"Movement Example - Irrlicht Engine ["); tmp += driver->getName(); tmp += L"] fps: ";
42
tmp += fps; device->setWindowCaption(tmp.c_str()); lastFPS = fps; } } //while
Para finalizar, se elimina el dispositivo. device->drop(); return 0; } //main
Compilar y probar. 2.6 Graphical User Inrface (GUI) A continuación se aborda en detalle cómo crear interfaces de usuario con el Engine Irrlicht. Se explica la forma en la que se crean y usan las ventanas, botones, barras de desplazamiento, textos estáticos y listas.
Como siempre, se agregan los archivos de cabecera y se habilitan los nombres de espacio, además se crea un putero para el dispositivo Irrlicht, un contador para cambiar la posición de las ventanas cuando son creadas y un puntero para una lista (listbox). #include <irrlicht.h> #include <iostream> using namespace irr; using namespace core; using namespace scene; using namespace video; using namespace io; using namespace gui; #ifdef _IRR_WINDOWS_ #pragma comment(lib, "Irrlicht.lib") #endif IrrlichtDevice *device = 0; s32 cnt = 0; IGUIListBox* listbox = 0;
El manejador de eventos, además de capturar los eventos de teclado y mouse, también maneja los eventos de la interfaz gráfica de usuario (GUI). Hay eventos definidos para casi cualquier cosa: clic sobre botón, cambio en la selección de una lista, eventos que indican que un elemento tiene el puntero encima, etc. Para responder a algunos eventos se debe crear un manejador de eventos, por ahora solo se necesitará responder
43
a eventos GUI de la siguiente forma: se obtiene el ID del elemento que ha causado el evento y un puntero al entorno GUI. class MyEventReceiver : public IEventReceiver { public: virtual bool OnEvent(const SEvent& event) { if (event.EventType == EET_GUI_EVENT) { s32 id = event.GUIEvent.Caller->getID(); IGUIEnvironment* env = device->getGUIEnvironment(); switch(event.GUIEvent.EventType) {
Si una barra de desplazamiento ha cambiado de valor, y corresponde con el id 104, entonces se establece el valor de transparencia de todos los elementos GUI. Ésta es una tarea fácil. Existe un objeto llamado skin en el cual están almacenadas todas las configuraciones de color, solo es necesario cambiar el valor de alpha (transparencia). case EGET_SCROLL_BAR_CHANGED: if (id == 104) { s32 pos = ((IGUIScrollBar*)event.GUIEvent.Caller)->getPos(); for (u32 i=0; i<EGDC_COUNT ; ++i) { SColor col = env->getSkin()->getColor((EGUI_DEFAULT_COLOR)i); col.setAlpha(pos); env->getSkin()->setColor((EGUI_DEFAULT_COLOR)i, col); } } break;
Si un botón ha sido presionado, podría ser cualquiera de los tres botones que se añadirán a la ventana. Si es el primero, se cerrará la aplicación; si es el segundo, se muestra una pequeña ventana con algún mensaje y se agrega una cadena a la lista (listbox) para registrar lo que ha ocurrido. Por último, si es el tercer botón, se crea un cuadro de diálogo para abrir un archivo y se agrega también una cadena al listbox. Eso es todo para el manejador de eventos. case EGET_BUTTON_CLICKED: if (id == 101) { device->closeDevice(); return true; } if (id == 102) { listbox->addItem(L"Window created"); cnt += 30; if (cnt > 200) cnt = 0; IGUIWindow* window = env->addWindow( rect<s32>(100 + cnt, 100 + cnt, 300 + cnt, 200 + cnt), false, // modal? L"Test window"
44
); env->addStaticText( L"Please close me", rect<s32>(35,35,140,50), true, // border? false, // wordwrap? window ); return true; } if (id == 103) { listbox->addItem(L"File open"); env->addFileOpenDialog(L"Please choose a file."); return true; } break; default: break; } } return false; } };
Ahora se debe crear el dispositivo Irrlicht. Como en los ejemplos anteriores, el usuario determinará cuál de los controladores de video se va a utilizar. int main() { // Elegir driver video::E_DRIVER_TYPE driverType; printf("Por favor elija el controlador de video a utilizar:\n"\ " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\ " (d) Software Renderer\n (e) Burning's Software Renderer\n"\ " (f) NullDevice\n (otherKey) exit\n\n"); char i; std::cin >> i; switch(i) { case 'a': driverType = video::EDT_DIRECT3D9;break; case 'b': driverType = video::EDT_DIRECT3D8;break; case 'c': driverType = video::EDT_OPENGL; break; case 'd': driverType = video::EDT_SOFTWARE; break; case 'e': driverType = video::EDT_BURNINGSVIDEO;break; case 'f': driverType = video::EDT_NULL; break; default: return 1; } // Crear el dispositivo o en su defecto terminar la ejecución.
45
device = createDevice(driverType, core::dimension2d<s32>(640, 480)); if (device == 0) return 1; // no se pudo crear el dispositivo.
Se ha creado satisfactoriamente, ahora se establece el manejador de eventos y se crean los punteros al driver y al entorno GUI. MyEventReceiver receiver; device->setEventReceiver(&receiver); device->setWindowCaption(L"Irrlicht Engine - User Interface Demo"); video::IVideoDriver* driver = device->getVideoDriver(); IGUIEnvironment* env = device->getGUIEnvironment();
Para hacer que el texto se vea un poco más interesante, se carga una fuente externa y se establece como la fuente por defecto del skin. Para conservar la fuente por defecto en los tool tips (globos de ayuda o información adicional que aparece al dejar el puntero por unos instantes sobre algún elemento GUI) se establece la fuente incluída en el Engine. IGUISkin* skin = env->getSkin(); IGUIFont* font = env->getFont("../../media/fonthaettenschweiler.bmp"); if (font) skin->setFont(font); skin->setFont(env->getBuiltInFont(), EGDF_TOOLTIP);
Ahora se agregarán los botones, el primero cierra el Engine, el segundo crea una ventana con un mensaje y el tercero abre el cuadro de diálogo de abrir archivo. El tercer parámetro del método ->addButton es el ID del botón, éste es utilizado para identificar fácilmente desde el manejador de eventos cuál de los botones ha sido presionado. Los otros parámetros de dicho método están definidos en los comentarios del código siguiente: env->addButton( rect<s32>(10,240,110,240 + 32), // posicionamiento 0, // padre 101, //ID L"Terminar", //Etiqueta L"Sale del programa" //Tooltip ); env->addButton( rect<s32>(10,280,110,280 + 32), 0, 102, L"Nueva ventana", L"Crea una nueva ventana" );
46
env->addButton( rect<s32>(10,320,110,320 + 32), 0, 103, L"Abrir Archivo", L"Abre un archivo" );
Ahora se agregará un texto estático y una barra de desplazamiento que modifique la opacidad de todos los elementos GUI. Se establece 255 como valor máximo, porque es el valor más alto utilizado en colores (1 byte). Luego se crea otro texto estático y el listbox. env->addStaticText(L"Transparent Control:", rect<s32>(150,20,350,40), true); IGUIScrollBar* scrollbar = env->addScrollBar( true, //horizontal rect<s32>(150, 45, 350, 60), //dimensiones 0, //parent 104 //ID ); scrollbar->setMax(255); // Establecer el valor de la barra de deslizamiento igual al valor alpha de // un elemento elegido arbitrariamente. scrollbar->setPos(env->getSkin()->getColor(EGDC_WINDOW).getAlpha()); env->addStaticText(L"Registro de sucesos:", rect<s32>(50,110,250,130), true); listbox = env->addListBox(rect<s32>(50, 140, 250, 210)); env->addEditBox(L"Texto editable", rect<s32>(350, 80, 550, 100));
Por último se agrega una imagen del logo del Engine en la esquina superior izquierda. env->addImage( driver->getTexture("../../media/irrlichtlogo2.png"), position2d<int>(10,10) );
Por ahora solo resta dibujar la escena.
while(device->run() && driver) if (device->isWindowActive()) { driver->beginScene(true, true, SColor(0,200,200,200)); env->drawAll(); driver->endScene(); } device->drop(); return 0; } //main
47
Al compilar y ejecutar la aplicación se verá una ventana como la que se muestra en la figura 2.6 2.7 Detección de colisiones A continuación se mostrará como detectar colisiones con el Engine Irrlicht, en esta sección se abarcan tres métodos: (1) Detección automática de colisiones para moverse por mundos tridimensionales con la capacidad para subir gradas y deslizarse, (2) selección manual de triángulos y (3) selección de nodos de escena. Para iniciar se utilizará el programa de la Sección 1.4 (Cargar mapas de Quake 3 y agregar una cámara FPS), el cual carga un nivel de Quake 3. Se utilizará dicho nivel para caminar en él y para tomar sus triángulos. Adicionalmente se agregan tres modelos animados a la escena. El siguiente código inicia el Engine y carga el mapa de Quake 3. Esto ya fue expuesto en la sección 1.4. #include <irrlicht.h> #include <iostream> using namespace irr; #ifdef _MSC_VER #pragma comment(lib, "Irrlicht.lib") #endif int main() { // let user select driver type video::E_DRIVER_TYPE driverType; printf("Por favor seleccione el driver a utilizar:\n"\ " (a) Direct3D 9.0c\n (b) Direct3D 8.1\n (c) OpenGL 1.5\n"\ " (d) Software Renderer\n (e) Burning's Software Renderer\n"\ " (f) NullDevice\n (otherKey) exit\n\n");
Figura 2.6. Algunos elementos de la interfaz gráfica de usuario incluida en el Engine Irrlicht.
48
char i; std::cin >> i; switch(i) { case 'a': driverType = video::EDT_DIRECT3D9;break; case 'b': driverType = video::EDT_DIRECT3D8;break; case 'c': driverType = video::EDT_OPENGL; break; case 'd': driverType = video::EDT_SOFTWARE; break; case 'e': driverType = video::EDT_BURNINGSVIDEO;break; case 'f': driverType = video::EDT_NULL; break; default: return 0; } // Crear el dispositivo IrrlichtDevice *device = createDevice( driverType, core::dimension2d<s32>(640, 480), 16, False ); if (device == 0) return 1; // no se pudo crear el driver seleccionado. video::IVideoDriver* driver = device->getVideoDriver(); scene::ISceneManager* smgr = device->getSceneManager(); device->getFileSystem()->addZipFileArchive("../../media/map-20kdm2.pk3"); scene::IAnimatedMesh* q3levelmesh = smgr->getMesh("20kdm2.bsp"); scene::ISceneNode* q3node = 0; if (q3levelmesh) q3node = smgr->addOctTreeSceneNode(q3levelmesh->getMesh(0));
Ahora algo diferente, crear el selector de triángulos. Un selector de triángulos o triangle selector es una clase con la que se pueden extraer los triángulos de nodos de escena para realizar diferentes cosas con ellos, por ejemplo: detección de colisiones. Hay diferentes selectores, y todos pueden ser creados con la ISceneManager. En este ejemplo se crea un OctTreeTriangleSelector, el cual optimiza un poco la salida de triángulos, reduciéndolo como un octree8, esto es muy útil con mallas enormes como los niveles de Quake 3. Después de que se ha creado el selector se atacha al objeto q3node. Esto no es realmente necesario pero de esta forma, no será necesario encargarse del selector por separado, por ejemplo para liberarlo cuando ya no se necesita más. scene::ITriangleSelector* selector = 0; if (q3node) {
8 Véase el término octree en el glosario.
49
q3node->setPosition(core::vector3df(-1350,-130,-1400)); selector = smgr->createOctTreeTriangleSelector( q3levelmesh->getMesh(0), q3node, 128 ); q3node->setTriangleSelector(selector); }
Ahora se agrega una cámara de tipo FPS a la escena para poder moverse a través del nivel de Quake 3. En esta ocasión, se agregará un animator especial a la cámara, que responda a colisiones (collision response animator). Esto modifica el nodo de escena al cual el animator ha sido atachado, de manera que el nodo de escena no puede moverse a través de las paredes del entorno y es afectado por la gravedad. Lo único que se debe indicar al animator es la forma que tiene todo el entorno, qué tan grande es el nodo de escena, el valor de la gravedad, etc. Luego de que el animator de respuesta a colisiones es atachado a la cámara, no se tendrá que hacer nada extra para la detección de colisiones, todo es hecho automáticamente. El animator de respuesta a colisiones también puede ser atachado a todos los otros nodos de escena, no solamente a cámaras, incluso puede ser combinado con otros animators. Ahora se examinan detenidamente los parámetros de createCollisionResponseAnimator(). El primer parámetro es el TriangleSelector, el cual especifica cómo “se ve el mundo”. El segundo parámetro es el nodo de escena, éste es el objeto que será afectado por la detección de colisiones, la cámara. El tercer parámetro define cuán grande es el objeto por medio de un elipsoide9 (definiendo sus tres radios). Al reducir los radios del elipsoide la cámara puede acercarse más a las paredes. El cuarto parámetro representa la dirección y velocidad de la gravedad. Puede establecer este valor a (0,0,0) para desactivar la gravedad. El quinto y último parámetro es sólo una traslación, sin esto la cámara quedaría justo en el centro del elipsoide, de manera que se colocará la cámara 50 unidades arriba del centro del elipsoide; con esto se hará funcionar la detección de colisiones. scene::ICameraSceneNode* camera = smgr->addCameraSceneNodeFPS(0, 100.0f, 300.0f, -1, 0, 0, true); camera->setPosition(core::vector3df(-100,50,-150)); if (selector) { scene::ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
9 Un elipsoide en matemáticas, es una cuádrica (ver glosario) análoga a la elipse, pero con una dimensión
más. Las secciones originadas por planos que contienen a los ejes ortogonales son elípticas. La ecuación
general de un elipsoide con centro en el origen de coordenadas, es: donde a, b y c son
números reales positivos que determinan la forma del elipsoide.
50
selector, //triangle selector camera, //Nodo de escena core::vector3df(30,50,30), //Radios del elipsoide core::vector3df(0,-3,0), //Gravedad core::vector3df(0,50,0) //Pos. Rel. del nodo al elipsoide. ); selector->drop(); camera->addAnimator(anim); anim->drop(); }
Ahora se agregan tres modelos animados, una luz dinámica para iluminarlos, un billboard para mostrar la intersección entre el puntero y el selector, además de ocultar el puntero del mouse. // Esconder el puntero del mouse device->getCursorControl()->setVisible(false); // Agregar el billboard scene::IBillboardSceneNode * bill = smgr->addBillboardSceneNode(); bill->setMaterialType(video::EMT_TRANSPARENT_ADD_COLOR ); bill->setMaterialTexture(0, driver->getTexture("../../media/particle.bmp")); bill->setMaterialFlag(video::EMF_LIGHTING, false); bill->setMaterialFlag(video::EMF_ZBUFFER, false); bill->setSize(core::dimension2d<f32>(20.0f, 20.0f)); // Cargar tres adas animadas. video::SMaterial material; material.setTexture(0, driver->getTexture("../../media/faerie2.bmp")); material.Lighting = true; scene::IAnimatedMeshSceneNode* node = 0; scene::IAnimatedMesh* faerie = smgr->getMesh("../../media/faerie.md2"); if (faerie) { node = smgr->addAnimatedMeshSceneNode(faerie); node->setPosition(core::vector3df(-70,0,-90)); node->setMD2Animation(scene::EMAT_RUN); node->getMaterial(0) = material; node = smgr->addAnimatedMeshSceneNode(faerie); node->setPosition(core::vector3df(-70,0,-30)); node->setMD2Animation(scene::EMAT_SALUTE); node->getMaterial(0) = material; node = smgr->addAnimatedMeshSceneNode(faerie); node->setPosition(core::vector3df(-70,0,-60)); node->setMD2Animation(scene::EMAT_JUMP); node->getMaterial(0) = material; } material.setTexture(0, 0);
51
material.Lighting = false; // Agregar un luz dinámica smgr->addLightSceneNode( 0, //padre core::vector3df(-60,100,400), //posición video::SColorf(1.0f,1.0f,1.0f,1.0f), //color RGBA 600.0f //radio de iluminación );
Para simplificar el proceso de detección de triángulos, se va a realizar la operación dentro del ciclo de dibujo. Se crean dos punteros para almacenar el actual y el último nodos de escena e iniciar el ciclo. scene::ISceneNode* selectedSceneNode = 0; scene::ISceneNode* lastSelectedSceneNode = 0; int lastFPS = -1; while(device->run()) if (device->isWindowActive()) { driver->beginScene(true, true, 0); smgr->drawAll();
Ahora se describirán las otras dos formas de hacer detección de colisiones. Después de haber dibujado la escena completa con smgr->drawAll(), se realiza la primera detección, se desea saber cuál de los triángulos que conforman la malla del escenario está apuntando la cámara y el punto exacto donde se intersecta la línea de visión con dicha malla. Para esto se crea una línea 3D (línea de visión), iniciando en la posición de la cámara y dirigiéndola hasta el punto donde la cámara está viendo (camera-
>getTarget()), luego se verifica en el manejador de colisiones si esta línea toca alguno de los triángulos del escenario guardados en el selector. Si es así, se dibuja un triángulo 3D que corresponde al triánguno detectado en la malla y se establece la posición del billboard en el punto de intersección.
core::line3d<f32> line; line.start = camera->getPosition(); line.end = line.start + (camera->getTarget() - line.start).normalize() * 1000.0f; core::vector3df intersection; core::triangle3df tri; if (smgr->getSceneCollisionManager()->getCollisionPoint( line, selector, intersection, tri)) { bill->setPosition(intersection);
driver->setTransform(video::ETS_WORLD, core::matrix4()); driver->setMaterial(material); driver->draw3DTriangle(tri, video::SColor(0,255,0,0)); }
Otra forma de detectar un nodo visible desde la cámara se basa en las cajas delimitadoras (o bounding boxtiene una caja delimitadora y en consecuencia resulta bastante rápido determinar qué nodo de escena está diréctamenmanejador de colisiones, utilizando el método Si dicho método devuelve un q3node, se procederá a desactivar selectedSceneNode = smgr-> if (lastSelectedSceneNode) lastSelectedSceneNode if (selectedSceneNode == q3node || selectedSceneNode == bill) selectedSceneNode = 0; if (selectedSceneNode) selectedSceneNode ); lastSelectedSceneNode = selectedSceneNode;
Para finalizar, se dibuja driver->endScene();
Figura 2.7.
un pato, delimitado por su
52
>setTransform(video::ETS_WORLD, core::matrix4()); rial(material);
>draw3DTriangle(tri, video::SColor(0,255,0,0));
a forma de detectar un nodo visible desde la cámara se basa en las cajas bounding box) de los nodos. Véase la figura 2.7. Cada nodo de escena
tiene una caja delimitadora y en consecuencia resulta bastante rápido determinar qué nodo de escena está diréctamente frente a la cámara. De nuevo, se verifica
utilizando el método ->getSceneNodeFromCameraBB(camera).un puntero a nodo de escena exceptuando los objetos
se procederá a desactivar la propiedad Lighting en su material.
selectedSceneNode = >
getSceneCollisionManager()-> getSceneNodeFromCameraBB(camera);
if (lastSelectedSceneNode) lastSelectedSceneNode->
setMaterialFlag(video::EMF_LIGHTING, true);
if (selectedSceneNode == q3node || selectedSceneNode == bill) selectedSceneNode = 0;
Node) selectedSceneNode->setMaterialFlag(
video::EMF_LIGHTING, false
lastSelectedSceneNode = selectedSceneNode;
Para finalizar, se dibuja la escena.
Figura 2.7. La figura muestra el nodo de escena de
un pato, delimitado por su bonding box.
a forma de detectar un nodo visible desde la cámara se basa en las cajas Cada nodo de escena
tiene una caja delimitadora y en consecuencia resulta bastante rápido determinar qué se verifica esto en el CameraBB(camera).
exceptuando los objetos billboard y
53
int fps = driver->getFPS(); if (lastFPS != fps) { core::stringw str = L"Colisiones - Irrlicht Engine ["; str += driver->getName(); str += "] FPS:"; str += fps; device->setWindowCaption(str.c_str()); lastFPS = fps; } } device->drop(); return 0; }
2.8 Audio 2D y 3D con irrKlang IrrKlang es una poderosa API de alto nivel para controlar la reproducción de sonidos en aplicaciones 3D y 2D como juegos, programas científicos de visualización y aplicaciones multimedia. Es un Engine de sonido 2D y 3D y librería de audio multiplataforma y se puede utilizar con C++ y todos los lenguajes de la plataforma .NET (C#, VisualBasic.NET, etc.). Tiene características incorporadas muy útiles como decodificadores de formatos de audio (wav, ogg, mp3, mod, xm, it, s3m...), un sofisticado mecanismo de streaming 10 , lectura de audio extensible, trabajo en modo simple y multihilo, capacidad para emular audio 3D, un sistemas de plugins (complementos o extensiones), múltiples modelos de rollof11 y más. Además es libre (open source) y puede ser utilizado para propósitos no comerciales. 2.8.1 EJECUTANDO SONIDOS (2D) A continuación se demuestra cómo ejecutar sonidos utilizando IrrKlang. Se ejecutará un sonido de fondo que se repite indefinidamente y un segundo sonido cada vez que se presiona una tecla. El SDK se puede descargar de: http://www.ambiera.com/irrklang/downloads.html, luego de instalado se agregan al proyecto los directorios lib\Win32-visualStudio e include, contenidos en el directorio de instalación del SDK, es un procedimiento muy similar al descrito en la sección 1.3 / Configurando el IDE. Los ejemplos y demás archivos necesarios para su implementación vienen también incluidos en el SDK en el directorio examples.
10
Más información sobre streaming en el glosario. 11
Vea el término rollof en el glosario.
54
Se procede, desde Visual Studio a crear un proyecto vacío (aplicación de consola). Para comenzar se deben incluir los archivos de cabecera. #include <iostream> #include <irrKlang.h>
Adicionalmente de la forma en que se declaran los nombres de espacio con Irrlicht, se debe indicar al compilador que se usará el nombre de espacio irrklang. Todas las clases y funciones de irrKlang se encuentran dentro del nombre de espacio irrklang. Para utilizar cualquier clase del Engine, se debe escribir irrklang:: antes del nombre de la clase. Por ejemplo, para usar la clase ISoundEngine, se escribe: irrklang::ISoundEngine. Para evitar escribir irrklang:: siempre que se usa una clase, se agregará instrucción using namespace
irrklang. using namespace irrklang;
Para poder acceder al archivo irrKlang.dll, se necesita vincular la aplicación con el archivo irrKlang.lib. Para ello basta con una instrucción pragma comment: #pragma comment(lib, "irrKlang.lib") // Vincular con irrKlang.dll
Para iniciar, se demostrará una simple ejecución de audio 2D. Se inicializa el Engine de sonido usando el método createIrrKlangDevice(). Dicho método puede requerir varios parámetros, por ahora bastará con los parámetros por defecto. int main(int argc, const char** argv) { // Inicializar el Engine de sonido con los parámetros por defecto ISoundEngine* Engine = createIrrKlangDevice(); if (!Engine) return 0; // error al iniciar el Engine
Para ejecuar un sonido simple, se utiliza el método play2D(). El primer parámetro hace referencia al archivo de sonido a ejecutar, el segundo parámetro de este método le indica al Engine que el sonido se va a ejecutar indefinidamente (al finalizar la reproducción inicia de nuevo). // Ejecutar el stream de audio, indefinidamente. Engine->play2D("../../media/getout.ogg", true);
El programa se ejecutará en un ciclo hasta que se presione la tecla q para salir de la aplicación o cualquier otra tecla para ejecutar el segundo archivo de sonido. std::cout << "\nHello World!\n"; char i = 0;
55
while(i != 'q') { std::cout << "Presione cualquier tecla para ejecutar un"\ "sonido o 'q' para salir.\n"; // Ejecutar un sonido simple Engine->play2D("../../media/bell.wav"); std::cin >> i; // esperar a que el usuario presione una tecla. }
Al finalizar el ciclo, se debe eliminar el dispositivo IrrKlang que se ha creado previamente con createIrrKlangDevice(), pare ello se utiliza el método drop(). En IrrKlang, al igual que en Irrlicht se deben eliminar todos los objetos que se hayan creado con un método o función que inicie con create. (play2D() y play3D() son excepciones a esta regla. Para ampliar esta información consulte la documentación12). Engine->drop(); // eliminar el Engine return 0; }
Sólo resta compilar y ejecutar la aplicación. 2.8.2 SONIDO 3D Cuando un sonido se ejecuta en un punto en particular del espacio, el cual tiene una distancia relativa al oyente, se denomirá sonido 3D. Esto puede lograrse gracias a los sistemas de audio estéreo de dos o más canales (Equipos de audio con dos o más bocinas). De modo que el sonido puede ejecutarse con un determinado volumen en cada una de las bocinas para simular cierto grado de cercanía desde el origen del sonido hacia el oyente. Por ejemplo el sonido puede trasladarse gradualmente de una bocina a la próxima, simulando el movimiento del origen del mismo. Véase la figura 2.8. 12
irrKlang 1.1.0 API documentation: http://www.ambiera.com/irrklang/docu/index.html
Figura 2.8. En la figura se muestra un sistema de audio con cinco bocinas, se está simulando que un objeto emisor de sonido se mueve alrededor del oyente. Como se puede apreciar, solamente algunas de las bocinas están activas.
56
A continuación se mostrará cómo ejecutar sonidos en el espacio 3D, utilizando irrKlang. Un archivo de audio mp3 será ejecutado en el espacio 3D y se moverá alrededor del usuario y otro sonido se ejecutará en una posición 3D aleatoria cada vez que se presione una tecla. Se necesita una función para dormir el programa por algunos segundos, entónces se incluirán los archivos específicos de la plataforma para poder acceder a dicha función. #ifdef WIN32 #include <windows.h> #include <conio.h> inline void sleepSomeTime() { Sleep(100); } #endif
También se incluyen los archivos de cabecera de entrada/salida necesarios para imprimir y obtener etradas de usuario desde la consola. #include <iostream> #include <stdio.h> #include <irrKlang.h> using namespace irrklang; #pragma comment(lib, "irrKlang.lib") // link with irrKlang.dll
A continuación se inicializa el Engine utilizando createIrrKlangDevice() con las opciones o parámetros por defecto. int main(int argc, const char** argv) { // Iniciar el enginde de sonido con los parámetros por defecto ISoundEngine* Engine = createIrrKlangDevice(); if (!Engine) return 0; // error starting up the Engine
Ahora se ejecutará indefinidamente el stream de sonido como música en el espacio 3D, se establecerá el último parámetro llamado 'track' a 'true' para hacer que irrKlang retorne un puntero al sonido ejecutado. (Este puntero también es devuelto si el parámetro 'startPaused' está definido como true). Notese que es neceario llamar al método ->drop del puntero retornado si ya no se necesita usar este sonido más adelante. Esto se hace al final del programa. // Ejecutar un sonido en el espacio ISound* music = Engine->play3D( "../../media/ophelia.mp3", //Archivo de sonido vec3df(0,0,0), // Posición true, //ejecutar indefinidamente (looped) false, //iniciar pausado (startPaused)
57
true //retornar un puntero al sonido para poder controlarlo (track) );
El siguiente paso no es realmente necesario, pero, para ajustar la distancia a la cual el sonido puede ser oído se definirá una distancia mínima (el valor por defecto es 1 para objetos pequeños). La distancia mínima es simplemente la distancia a la cual el sonido es ejecutado con su volumen máximo. if (music) music->setMinDistance(5.0f);
Imprimir un texto de ayuda e iniciar el ciclo: printf("\nEjecutando sonido en 3D."); printf("\nPresiones ESCAPE para salir, cualquier otra tecla "\ "para ejecutar otro sonido en una posición aleatoria.\n\n"); printf("+ = Posición de quien escucha\n"); printf("o = Ejecutando sonido\n"); float posOnCircle = 0; const float radius = 5; while(true) { // ciclo infinito, hasta que el usuacio salga
Para cada paso por el ciclo se calcula la posición de la música en el espacio, en este ejemplo se hará que la música rote su posición sobre una circunferencia. posOnCircle += 0.04f; vec3df pos3d(radius * cosf(posOnCircle), // X 0, // Y radius * sinf(posOnCircle * 0.5f) // Z );
Después de calcular la posición de la música se debe indicar a irrKlang la posición de quien escucha (en este caso (0,0,0), con dirección hacia adelante). Engine->setListenerPosition(vec3df(0,0,0), //posición del oyente (listener) vec3df(0,0,1)); //dirección (lookdir) if (music) music->setPosition(pos3d);
Ahora se imprimirá la posición del sonido representada en una cadena y también un medidor de avance de reproducción. char stringForDisplay[] = " + "; int charpos = (int)((pos3d.X + radius) / radius * 10.0f); if (charpos >= 0 && charpos < 20)
58
stringForDisplay[charpos] = 'o'; int playPos = music ? music->getPlayPosition() : 0; printf("\rx:(%s) 3dpos: %.1f %.1f %.1f, playpos:%d:%.2d ", stringForDisplay, pos3d.X, pos3d.Y, pos3d.Z, playPos/60000, (playPos%60000)/1000 ); sleepSomeTime();
Manejo de teclado: Cada vez que el usuario presiona una tecla en la consola se ejecuta un sonido aleatorio o sale de la aplicación si se ha presionado ESC. if (kbhit()) { //si se ha presionado una tecla int key = getch(); //obtener la tecla if (key == 27) // Código para la tecla ESC break; else {
Ahora se procede a ejecutar el sonido en una posición aleatoria. El método play3D() no retorna ningún puntero (devuelve 0) porque no se ha establecido a true ninguno de los parámetros startPaused (iniciar pausado) o track (como se hizo anteriormente con la múscia). Por esta razón no es necesario llamar a drop(). vec3df pos(fmodf((float)rand(),radius*2)-radius, 0, 0); //posición aleatoria const char* filename; if (rand()%2) //se elige un sonido al azar filename = "../../media/bell.wav"; else filename = "../../media/explosion.wav"; Engine->play3D(filename, pos); //ejecutar filename en la posición pos printf("\nreproduciendo %s en %.1f %.1f %.1f\n", filename, pos.X, pos.Y, pos.Z);
Por ahora solo resta liberar los recursos cuando el programa finaliza. } } } // No olvide liberar los recursos como se explicó. if (music) music->drop(); // release music stream. Engine->drop(); // eliminar el Engine return 0;
59
}
Además de permitir ejecutar sonido 2D y 3D, irrKlang incorpora una serie de efectos especiales que pueden aplicarse a cualquier sonido. Entre ellos se incluye el Efecto Doppler13 , coro, compresión, distorsión, echo, flanger14 , gargling15 , reverb 16 y efectos de ecualización paramétrica, entre otros. Puede obtenerse una completa referencia de la API de IrrKlang, tutoriales y otros recursos en http://www.ambiera.com/irrklang 2.9 irrXML irrXML es un parser o analizador sintáctico para leer archivos XML con datos no validados (asume que están sintácticame correctos de acuerdo al lenguaje XML), es rápido y simple, de código abierto, escrito en C++ y compatible con lenguajes .NET. Este parser de XML viene incluido en el Engine Irrlicht pero también puede obtenerse por separado para usarlo en cualquier tipo de aplicación. Más información en: http://www.ambiera.com/irrxml Si se usa de forma independiente simplemente se debe agregar al proyecto el directorio /src incluído en el SDK de irrXML. Para usuarios Linux / Unix se debe ir al directorio /examples y ejecutar la instrucción ‘make’ en la consola, esto creará un proyecto simple que incluye irrXML. A continuación se describe un breve ejemplo que muestra como acceder a un archivo XML: config.xml. <?xml version="1.0"?> <config> <!-- Este es un archivo de configuración para el visor de mallas --> <model file="dwarf.dea" /> <messageText caption="Visor de mallas del Engine Irrlicht"> Bienvenido al visor de mallas de "Irrlicht Engine". </messageText> </config>
El programa que leerá el archivo XML simplemente guarda los datos obtenidos en las variables messageText, modelFile y Caption. Luego de obtenida la información se puede proceder a realizar cualquier acción, por ejemplo, desplegarla en pantalla.
13
Efecto Doppler: Consiste en la variación de la longitud de onda de cualquier tipo de onda emitida o
recibida por un objeto en movimiento y que se produce a causa del mismo movimiento. 14
Efecto flanger: Consiste en mezclar la señal original de audio con una copia retardada en el tiempo, con la
particularidad que el retardo es muy breve pero varía de forma periódica. 15
Efecto gargling: Consiste variar la señal de audio de forma que suene como si se hicieran “gárgaras”. 16
Efecto reverb: Este es el efecto que se aplica al material de audio para dar al oyente la impresión que está
en otro cuarto.
60
#include <irrXML.h> using namespace irr; // localizar irrXML. using namespace io; // usando el nombre de espacio irr::io
#include <string> // Usamos cadenas STL17 para almacenar los datos // en este ejemplo. void main() { // Creamos el lector usando una de las funciones de creación IrrXMLReader* xml = createIrrXMLReader("config.xml"); // Algunas cadenas para almacenar los datos que obtenemos del archivo xml std::string modelFile; std::string messageText; std::string caption; // leer el archivo hasta que se encuentre el final del mismo. while(xml && xml->read()) { switch(xml->getNodeType()) { case EXN_TEXT: // En este archivo xml, el único texto se encuentra dentro de las // etiquetas <messageText> y </messageText> messageText = xml->getNodeData(); break; case EXN_ELEMENT: if (!strcmp("model", xml->getNodeName())) //etiqueta model modelFile = xml->getAttributeValue("file"); //atributo file else if (!strcmp("messageText", xml->getNodeName())) //etiqueta messageText caption = xml->getAttributeValue("caption"); //atributo caption break; } } // Liberar la memoria delete xml; }
17
STL o Standard Template Library es una librería de software parcialmente incluida en la librería estándar
de C++. Provee contenedores, iteradores, algoritmos y funciones utilizados para manejar diferentes
estructuras de datos de computadoras.
RakNet es una librería para manejo de red basada en UDP. Está diseñada para permitir a los programadores capacidad de respuesta en tiempo crítico a sus aplicaciones de red.
61
Capítulo III
RakNet
kNet es una librería para manejo de red basada en UDP. Está diseñada para permitir a los programadores agregar capacidad de respuesta en tiempo crítico a sus aplicaciones de
kNet es una librería para manejo de red basada en UDP. agregar
capacidad de respuesta en tiempo crítico a sus aplicaciones de
62
63
3.1 Introducción RakNet es una librería para manejo de red basada en UDP. Está diseñada para permitir a los programadores agregar capacidad de respuesta en tiempo crítico a sus aplicaciones de red. Es utilizada principalmente para videojuegos, pero es independiente de la aplicación que se le quiera dar. RakNet está diseñada para ser veloz, fácil de usar, independiente de la aplicación, independiente de la plataforma y flexible. RakNet está bajo licencias diferentes, de acuerdo al tipo de servicio o aplicación que se va a desarrollar. Para aplicaciones no comerciales aplica Creative Commons “Reconocimiento-No comercial 2.5 Genérica 18 ”. En el caso de aplicaciones simples para desarrolladores individuales aplica la licencia “Indy 19 ”. Para desarrolladores mayores, la licencia “Developer” y para Engines de juegos y aplicaciones grandes aplica “Publisher license”. Más información en: http://www.jenkinssoftware.com/purchase.html 3.2 Características Entre las características más importantes se encuentran las siguientes:
• Lobby System: Es un plugin que provee funcionalidad controlada por una base de datos PostgreSQL para datos persistentes de juegos y matchmaking20.
• Sistema de replicación de objetos: Permite de manera automática crear, destruir, serializar21 y transmitir los objetos de la aplicación o juego en desarrollo.
• Conexiones Seguras22: Soporte para SHA1, AES128, SYN Cookies, y RSA para prevenir y detectar ataque de red.
• Robusta capa de comunicación: Control automático de flujo, ordenamiento de mensajes en múltiples canales, coalescence 23 de mensajes y segmentación y reemsamblado de paquetes.
• Autopatcher: Consiste en una clase que maneja la actualización de paquetes perdidos o modificados entre dos sistemas.
• Llamadas a procedimientos remotos: Puede llamar a procedimientos nativos de C y C++ con listas de parámetros automáticamente serializadas.
• Comunicación por voz: Incluye bindings de audio para Port Audio24 , FMOD y DirectSound.
• NAT 25 Punchthrough: Si ambas máquinas se encuentran detrás de un NAT (router), es imposible para ellas conectarse entre sí, a menos que ambas conozcan la dirección pública y puerto de la otra. La clase NatPunchthrough
18
Creative Commons “Reconocimiento-No comercial 2.5 Genérica”,
http://creativecommons.org/licenses/by-nc/2.5/deed.es 19
Indy License, http://www.jenkinssoftware.com/IndyLicense-1.0.pdf 20
Matchmaking: Término inglés que se refiere al proceso de ayudar a las personas a encontrar pareja. 21
Vea serialización en el glosario. 22
Para más información de cada uno de los términos SHA1, AES128, SYN Cookies, y RSA consulte el glosario. 23
Coalescence: Es la acción de fusionar dos bloques adyacentes de memoria libre. 24
Port Audio: Es una librería para grabar y reproducir audio. Es independiente de la plataforma y de código
abierto. 25
NAT: Acrónimo de Network Address Translation. Mapea dirección IP públicas a direcciones IP locales.
64
implementa esta técnica permitiendo a ambos sistemas conectarse a través de un tercer sistema llamado facilitador, éste no se encuentra detrás de NAT y actúa como un intermediario en la comunicación.
3.3 Incluir RakNet en un proyecto 26 Hay varias formas de incluir RakNet en un proyecto: puede utilizar el código fuente, una librería estática o bien una DLL. En este texto se explicará cómo incluir el código fuente de RakNet en un proyecto de Visual Studio 2005. La ventaja de hacerlo de esta manera es que permite que en cualquier momento se pueda acceder al código de todas las clases y sus métodos para conocer el órden de los parámetos, los atributos de clase, etc. El código fuente de RakNet incluye una amplia documentación interna con comentarios y descripciones detalladas. Lo primero que se debe hacer es agregar el directorio /Source al proyecto. No todos los archivos son estrictamente necesarios, pero los que no se usen tampoco estorbarán. Sin embargo, si no se planea utilizar RakVoice podrían excluirse todos los archivos que incluyan RakVoice en su nombre, de otra forma se deben incluir todos los archivos speex27. Si se necesita incluir RakVoice se debe agregar lo siguiente:
• Los archivos fuente contenidos en el directorio DependentExtensions\speex-
x.x.xx\libspeex. • Agregar a los directorios include adicionales "Additional Include Directories" el lo
siguiente: ..\..\..\Source;..\..\..\speex-1.1.4\libspeex.
A continuación se debe importar ws2_32.lib o bien wsock32.lib si no se tiene instalado Winsock 2. En VisaulStudio.NET se incluye haciendo clic derecho sobre el proyecto, luego se selecciona configuration properties (propiedades de configuración) > linker > input > additional dependencies y ahí se agrega el archivo "ws2_32.lib", como se vé en la figura 3.2.
26
Fuente: Compiler Setup, http://www.jenkinssoftware.com/raknet/manual/compilersetup.html 27
El proyecto Speex tiene como objetivo crear un códec libre para voz, sin restricciones de ninguna patente
de software. Speex está sujeto a la Licencia BSD y es usado con el contenedor Ogg de la Fundación Xiph.org.
Fuente: http://es.wikipedia.org/wiki/Speex
Figura 3.2. Incluir ws2_32.lib en el proyecto (o en su defecto, incluya wsock32.lib)
65
También se debe configurar el proyecto para usar las librerías en tiempo de ejecución multi-hilo (multi-threaded runtime libraries). En VisualStudio.NET se debe hacer clic derecho sobre el proyecto, seleccionar las propiedades de configuración (configuration properties) > C/C++ > Code Generation > Runtime Library, y por último cambiar el valor a Multi-threaded (/MT), como se aprecia en la figura 3.3.
Opcionalmente se pueden configurar las directivas de preprocesador. Más información al respecto en: http://www.jenkinssoftware.com/raknet/manual/preprocessordirectives.html 3.4 Comunicación básica: envío de cadenas A continuación se ejemplificará el funcionamiento básico de RakNet, se crean dos proyectos incluyendo RakNet (tal y como se mostró en la sección anterior), un servidor y un cliente. Los clientes (instancias de la aplicación client) al momento de iniciar, solicitan la dirección IP del servidor y se conectan por el puerto 60000, luego de conectados envían cadenas de texto al servidor por medio de paquetes. Los archivos de proyecto se incluyen en el CD que acompaña a este material. 3.4.1 SERVIDOR (MAIN.CPP) Para comenzar se deben incluir los archivos de cabecera. El archivo stdio.h es para entrada y salida desde la consola. RakNetworkFactory.h contiene las clases de creación de todos los objetos de RakNet, RakPeerInterface.h es una interfaz de RakPeer que contiene todas las funciones de usuario definidas como virtuales puras 28 . El archivo MessageIdentifiers.h contiene todos los identificadores de mensajes utilizados por RakNet. Un identificador de mensaje es el número contenido en el primer byte de cada mensaje. #include <stdio.h> #include "RakNetworkFactory.h" #include "RakPeerInterface.h" #include "MessageIdentifiers.h"
28
Las funciones virtuales puras definen la interfaz de una clase abstracta (que no se va a instanciar). La clase
abstracta es simplemente una interfaz para todas las clases derivadas de ésta, las cuales pueden redefinir las
funciones virtuales.
Figura 3.3. Establecer el proyecto para usar Multi-threaded en las librerías runtime.
66
Ahora se define el número máximo de clientes y el puerto a utilizar para la comunicación #define MAX_CLIENTS 10 #define SERVER_PORT 60000
RakPeerInterface es la interfaz principal de RakNet, RakPeer contiene todas las funciones principales de la librería. Se crea un objeto llamado peer que permitirá controlar la comunicación. RakPeerInterface *peer;
Ahora se define un procedimiento para imprimir los mensajes recibidos. void PrintMessage(RPCParameters *rpcParameters) { printf("%s\n", rpcParameters->input); }
RakPeerInterface::RPC llama a una función de C en el sistema remoto que fue registrado usando RegisterAsRemoteProcedureCall(). Sus parámetros son:
• uniqueID: Una cadena terminada en NULL que identifica la función a llamar. Es recomendable usar la macro CLASS_MEMBER_ID para funciones de clase.
• data: Los datos a enviar. • bitLength: El número de bits de los datos. • priority: Establecer el nivel de prioridad del envío. (Véase el archivo PacketPriority.h) • reliability: Fiabilidad de los datos. (Véase el archivo PacketPriority.h) • orderingChannel: Cuando se envían los mensajes en orden o secuencia, respecto
de qué canal se debe ordenar. • systemAddress: A quien envíar este mensaje o en el caso de usar broadcast a
quien no envíar el mensaje. Para especificar ninguno use UNASSIGNED_SYSTEM_ADDRESS
• broadcast: establecer a True para envíar el mensaje como broadcast. • includedTimestamp: Pase un valor para ajustar el tiempo por defecto como
ID_TIMESTAMP. 0 para no utilizar esta característica. • networkID: Para funciones estáticas pase UNASSIGNED_NETWORK_ID. Para
funciones miembro debe derivar de NetworkIDObject y pasar el valor retornado por NetworkIDObject::GetNetworkID para ese objeto.
• replyFromTarget: Si el valor es diferente de 0 se bloqueará hasta que reciba una respuesta desde el procedimiento de destino, el cual debe estar remotamente escrito por RPCParameters::replyToSender y copiado a replyFromTarget.
peer->RPC( "PrintMessage", (const char*)rpcParameters->input,
67
rpcParameters->numberOfBitsOfData, HIGH_PRIORITY, RELIABLE_ORDERED, 0, rpcParameters->sender, true, 0, UNASSIGNED_NETWORK_ID, 0 ); }
Ahora en main(), se crea un paquete (packet) el cual se utilizará para recibir todos los mensajes que lleguen a la aplicación. Se crea la interfaz de comunicación en peer y se inicializa el servidor con StartUp. int main(void) { Packet *packet; peer = RakNetworkFactory::GetRakPeerInterface(); peer->Startup( MAX_CLIENTS, //Conexiones entrantes 30, Cuantos milisegundos debe esperar para cada ciclo de actualizacion &SocketDescriptor( //Local socket SERVER_PORT, //Puerto del servidor 0 //Dirección del host, 0 = local ), 1 //Tamaño del arreglo de SocketDescriptor. ); printf("Starting the server.\n"); // Necesitamos permitir al servidor aceptar conexiones entrantes de los clientes. peer->SetMaximumIncomingConnections(MAX_CLIENTS); REGISTER_STATIC_RPC(peer, PrintMessage); while (1) {
A continuación resta recibir los paquetes entrantes. packet=peer->Receive();
Luego de recibido el paquere, se verifica el contenido del primer byte de datos del paquete. El primer byte se usa para indicar el tipo de paquete que se ha recibido. while(packet) { switch (packet->data[0]) { case ID_REMOTE_DISCONNECTION_NOTIFICATION: printf("Otro cliente se ha desconectado.\n");
68
break; case ID_REMOTE_CONNECTION_LOST: printf("Otro cliente ha perdido la conexion.\n"); break; case ID_REMOTE_NEW_INCOMING_CONNECTION: printf("Otro cliente se ha conectado.\n"); break; case ID_CONNECTION_REQUEST_ACCEPTED: printf("Nuestra petición de conexión ”\ “ha sido aceptada.\n"); break; case ID_NEW_INCOMING_CONNECTION: printf("Hay una conexión entrante.\n"); break; case ID_NO_FREE_INCOMING_CONNECTIONS: printf("El servidor está lleno.\n"); break; case ID_DISCONNECTION_NOTIFICATION: printf("Un cliente se ha desconectado.\n"); break; case ID_CONNECTION_LOST: printf("Un cliente ha perdido la conexión.\n"); break; default: printf( "El mensaje con el identificacdor "\ "%i ha llegado.\n", packet->data[0] ); break; }
Liberar el paquete. peer->DeallocatePacket(packet); // Permanecer en el ciclo hasta que no haya mas paquetes. packet = peer->Receive(); } }
Liberar la conexión. RakNetworkFactory::DestroyRakPeerInterface(peer); return 0; }
69
2.4.2 CLIENTE (MAIN.CPP) Como se mencionó anteriormente, el cliente se conecta al servidor por medio del puerto 60000, inicialmente pide la dirección IP del servidor y una vez conectado espera a que el usuario ingrese una cadena para enviarla al servidor. Además de los archivos de cabecera del ejemplo anterior se incluirá string.h para poder utilizar strcpy(). //Cliente #include <stdio.h> #include <string.h> #include "RakNetworkFactory.h" #include "RakPeerInterface.h" #include "MessageIdentifiers.h" #define SERVER_PORT 60000 RakPeerInterface *peer;
Procedimiento para imprimir los mensajes recibidos. void PrintMessage(RPCParameters *rpcParameters) { printf("%s\n", rpcParameters->input); }
Se crea una cadena (str) para ingresar la dirección IP del servidor y los mensajes a envíar. int main(void) { char str[512]; Packet *packet; peer = RakNetworkFactory::GetRakPeerInterface(); peer->Startup(1,30,&SocketDescriptor(), 1); printf("Enter server IP or hit enter for 127.0.0.1\n"); gets(str); if (str[0]==0){ strcpy(str, "127.0.0.1"); } printf("Iniciando el Cliente.\n");
Aquí se realiza la conexión al servidor. peer->Connect( str, //Dirección SERVER_PORT, //Puerto remoto 0, //PasswordData 0 //PasswordDataLength
70
);
Se registra la función PrintMessage para poder llamarla remotamente. REGISTER_STATIC_RPC(peer, PrintMessage); while (1) {
Luego se detiene la ejecución del programa en espera de que el usuario ingrese una cadena para envíar. printf("Ingrese una cadena para mostrar en el servidor: "); gets(str);
Al envíar una cadena, se debe estar seguro que finaliza en NULL, por tanto, se debe definir la longitud a strlen(str)+1. RPC toma la longitud de bits de los datos (no de bytes), por lo que es necesario multiplicar el número de bytes por 8. //Verificar que no sea una cadena vacía. if (str[0]) peer->RPC( "PrintMessage", //Nombre de la función a llamar str, //Datos a envíar (strlen(str)+1)*8, //Longitud de datos HIGH_PRIORITY, //prioridad RELIABLE_ORDERED, //fiabilidad 0, //Orden de canales UNASSIGNED_SYSTEM_ADDRESS, //Dirección del destinatario true, // Broadcast 0, // TimeStamp UNASSIGNED_NETWORK_ID, //NetWorkID 0 //Respuesta desde el destino );
Recibir y gestionar los paquetes entrantes. packet=peer->Receive(); while(packet) { switch (packet->data[0]) { case ID_REMOTE_DISCONNECTION_NOTIFICATION: printf("Otro cliente se ha desconectado.\n"); break; case ID_REMOTE_CONNECTION_LOST: printf("Otro cliente ha perdido la conexión.\n"); break; case ID_REMOTE_NEW_INCOMING_CONNECTION: printf("Otro cliente se ha conectado.\n"); break; case ID_CONNECTION_REQUEST_ACCEPTED:
71
printf("Nuestra solicitud de conexión "\ "ha sido aceptada.\n"); break; case ID_NEW_INCOMING_CONNECTION: printf("Hay una conexión entrante.\n"); break; case ID_NO_FREE_INCOMING_CONNECTIONS: printf("El servidor está lleno.\n"); break; case ID_DISCONNECTION_NOTIFICATION: printf("Hemos sido desconectados.\n"); break; case ID_CONNECTION_LOST: printf("La conexión se ha perdido.\n"); break; default: printf("Ha llegado el mensaje con Id: %i.\n", packet->data[0]); break; } peer->DeallocatePacket(packet); // Permanecer en el ciclo hasta que no haya mas paquetes. packet = peer->Receive(); } }
Destruir la interfaz de comunicación. RakNetworkFactory::DestroyRakPeerInterface(peer); return 0; }
Sólo resta compilar ambos proyectos, ejecutar el servidor y una o varias instancias del cliente. 3.5 Irrlicht y RakNet, envío de estructuras En esta sección se mostrará una aplicación que envía estructuras de datos por medio de RakNet, a diferencia de la sección anterior en la que se enviaban solo cadenas de texto. Los archivos de proyecto se incluyen en el CD que acompaña a este documento. Dicha aplicación consiste en dos programas, un cliente y un servidor. El servidor contiene un cubo rotando y visible en pantalla y recibe eventos que le indican que se debe desplazar por el plano XZ o cambiar la dirección de su rotación; estos eventos son interceptados en el programa cliente y enviados como una estructura de datos al programa servidor. De nuevo es necesario hacer dos proyectos, un servidor y un cliente, en ambos proyectos se han incluído los archivos fuente de RakNet. El servidor incluye la librería
72
Irrlicht.lib para acceder a la API de Irrlicht, se crea un nodo de escena (un cubo) y se le añade un animator de rotación. El programa cliente intercepta varias teclas: W, A, S, D y R que tienen la función de desplazar al cubo creado en el servidor en el plano XZ (teclas W, A, S y D) y cambiar la dirección de rotación (tecla R). Además de los dos archivos main.cpp (del cliente y servidor) se crea un tercer archivo llamado id_msg.h, el cual contiene una enumeración con los IDs de los mensajes que se envían entre el servidor y el cliente, además de la estructura de los mensajes y una función que convierte una serie de bytes (char *) en un objeto de la estructura de mensajes. 3.5.1 CABECERA COMPARTIDA (ID_MSG.CPP)
Este archivo se debe incluír en ambos proyectos. Assert se incluye para abortar el programa en caso de error al convertir los datos del paquete a la estructura de mensaje. #include <assert.h>
La siguiente enumeración se usa para definir todos los IDs de los mensajes entre el cliente y el servidor, se debe iniciar siempre con ID_USER_PACKET_ENUM para que no se traslapen con los IDs de los mensajes propios de RakNet. //IDs de los eventos propios de juego enum { //Moviemiento de los jugadores ID_MOVE = ID_USER_PACKET_ENUM, //Rotación ID_ROTATE };
Ahora se define la estructura Message. En este caso sólo se necesita un ID para el tipo de mensaje a enviar y dos variables de coma flotante x, z para mover el cubo por el plano XZ. Las instrucciones #pragma pack(push,1) y #pragma pack(pop) son indispensables para poder enviar la estructura como una secuencia de bytes; lo que hacen es forzar al compilador a empaquetar la estructura como una sucesión de bytes alieados. #pragma pack(push, 1) struct Message{ unsigned char ID; float x, z; }; #pragma pack(pop)
73
Por último se define una función que permite convertir los datos de un paquete (char *) a un objeto de tipo Message. En caso de que la longitud del paquete no concuerde con el tamaño del mensaje se aborta la ejecución del programa. Message str2message(Packet *packet) { // Asignar los bytes de datos al tipo adecuado de estructura Message *m = (Message *) packet->data; assert(packet->length == sizeof(Message)); return *m; }
3.5.2 SERVIDOR (MAIN.CPP) Como en los ejemplos anteriores, se incluyen los archivos de cabecera de Irrlicht y de RakNet, stdio para entrada y salida estándar y el archivo id_msg.h que está fuera de la carpeta del poyecto (anteponer ../). También se vinclulará con Irrlicht.DLL, se oculta la consola y se indica que se utilizará el nombre de espacio irr. #include <stdio.h> #include <irrlicht.h> #include "RakNetworkFactory.h" #include "RakPeerInterface.h" #include "MessageIdentifiers.h" #include "../id_msg.h" //Vincular ocn Irrlicht.dll #pragma comment(lib, "Irrlicht.lib") //Ocultar la ventana de consola #pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup") using namespace irr;
Luego se define el número máximo permitido de conexiones al servidor y el puerto a utilizar. #define MAX_CLIENTS 10 #define SERVER_PORT 60000
Se declara la interfaz de comunicación peer. RakPeerInterface *peer;
Ahora se inicia el dispositivo Irrlicht, se establece el título para la ventana y se crean los punteros a manejador de video y de escena. int main(void) {
74
/* --- Objetos de Irrlicht */ IrrlichtDevice *device = irr::createDevice( video::EDT_DIRECT3D9, //Manejador de video core::dimension2d<s32>(640,480), //Tamaño de la ventana 16, //Profundidad de color false, //Pantalla completa false, //stencil buffer false, //vsync 0 //Manejador de eventos ); device->setWindowCaption(L"Ejemplo de Irrlicht y RakNet por Cristiandlr"); //Punteros video::IVideoDriver *driver = device->getVideoDriver(); scene::ISceneManager *smgr = device->getSceneManager();
Luego se crea un cubo, se le asigna una textura y se desactiva la iluminación a falta de una luz dinámica en la escena. También se le agrega un animator para hacerlo rotar respecto del eje Y. //Agregamos un nodo de escena (un cubo) para poder mover scene::ISceneNode *node = smgr->addCubeSceneNode(); //moverlo al origen node->setPosition(core::vector3df(0,0,0)); //agregar una textura al cubo node->setMaterialTexture(0,driver->getTexture("./cruz.jpg")); //desactivar la iluminación node->setMaterialFlag(video::EMF_LIGHTING, false); //Agregar un animator de rotación scene::ISceneNodeAnimator *a=0; a = smgr->createRotationAnimator(core::vector3df(0,2.0f,0)); node->addAnimator(a); a->drop();
Para poder visualizar la escena se necesita añadir una cámara, la cual se apuntará al origen que es donde se colocó inicialmente el cubo y se posiciona en (0,0,-50). //añadir una cámara y apuntarla al origen smgr->addCameraSceneNode( 0, //parent core::vector3df(0,0,-50), //posicion core::vector3df(0,0,0) //ver hacia );
75
Ahora se definen los objetos de RakNet, un puntero packet para recibir los paquetes que lleguen desde los clientes, se inicia la interfaz de comunicación y se establece el número máximo de conexiones entrantes. /* --- Objetos de RakNet */ Packet *packet; peer = RakNetworkFactory::GetRakPeerInterface(); peer->Startup(MAX_CLIENTS, 30, &SocketDescriptor(SERVER_PORT,0), 1); printf("Starting the server.\n"); // We need to let the server accept incoming connections from the clients peer->SetMaximumIncomingConnections(MAX_CLIENTS);
Se requiere un objeto de tipo Message para “reacomodar los bytes” que llegan en los paquetes a su estructura original. La variable booleana direction se utiliza para determinar si el animator de rotación gira a la derecha o a la izquierda. /* --- Objetos propios del ejemplo */ Message m; bool direction=true;
Se inicia el ciclo principal, se repite mientra el dispositivo esté en ejecución. while (device->run()) { driver->beginScene( true, //backbuffer true, //zbuffer video::SColor(255,100,101,140) //color );
Se captura el paquete. Si el ID del paquete (packet->data[0]) es mayor o igual a ID_USER_PACKET_ENUM se sabrá que es un mensaje definido para este programa y no uno de RakNet, entonces se asigna al objeto m para acceder a la información que contiene. packet=peer->Receive(); while(packet) { if (packet->data[0]>= ID_USER_PACKET_ENUM) m = str2message(packet); switch (packet->data[0]) {
Se compara el ID del paquete para verificar el tipo de mensaje.
76
case ID_REMOTE_DISCONNECTION_NOTIFICATION: printf("Otro cliente se ha desconectado.\n"); break; case ID_REMOTE_CONNECTION_LOST: printf("Otro cliente ha perdido la conexión.\n"); break; case ID_REMOTE_NEW_INCOMING_CONNECTION: printf("Otro cliente se ha conectado.\n"); break; case ID_CONNECTION_REQUEST_ACCEPTED: printf("Nuestra conexión ha sido aceptada.\n"); break; case ID_NEW_INCOMING_CONNECTION: printf("Hay una conexión entrante.\n"); break; case ID_NO_FREE_INCOMING_CONNECTIONS: printf("El Servidor está lleno.\n"); break; case ID_DISCONNECTION_NOTIFICATION: printf("Un cliente se ha desconectado.\n"); break; case ID_CONNECTION_LOST: printf("Un cliente perdió la conexión.\n"); break;
En caso de que el ID corresponda con ID_MOVE, se establece la nueva posición del cubo en la escena. case ID_MOVE: node->setPosition(core::vector3df(m.x, 0, m.z)); break;
Si el ID corresponde con ID_ROTATE, se cambia la dirección de rotación del cubo. Como este nodo ya contiene un animator de rotación, debe ser eliminado antes de agregar el nuevo animator con la dirección adecuada. case ID_ROTATE: node->setPosition(core::vector3df(m.x, 0, m.z)); direction=!direction; //quitar el animator actual node->removeAnimators(); if(direction) { a = smgr->createRotationAnimator( core::vector3df(0,2.0f,0) ); } else { a = smgr->createRotationAnimator( core::vector3df(0,-2.0f,0) ); }
77
node->addAnimator(a); a->drop(); break;
Si el ID del mensaje no está entre las opciones, simplemente se depliega un mensaje al usuario por medio de la consola. Luego de liberar el paquete, se verifica si hay más paquetes en espera, si los hay, continúa el el ciclo. default: printf("Mensaje desconocido, id=%i.\n", packet->data[0]); break; } //Liberar el paquete. peer->DeallocatePacket(packet); // Permanecer en el ciclo hasta que no haya más paquetes. packet = peer->Receive(); }
Sólo resta dibujar la escena. smgr->drawAll(); driver->endScene(); }
Se libera la interfaz de comunicación antes de salir por completo. RakNetworkFactory::DestroyRakPeerInterface(peer); return 0; }
3.5.3 CLIENTE (MAIN.CPP) Para iniciar, se incluyen los archivos de cabecera para entrada y salida estándar en la consola, string.h para manejo de cadenas, cabeceras de RakNet y por último id_msg.h. //Cliente #include <stdio.h> #include <conio.h> #include <string.h> #include "RakNetworkFactory.h" #include "RakPeerInterface.h" #include "MessageIdentifiers.h" #include "../id_msg.h"
Ahora se define el puerto y la interfaz de comunicación, en este programa no se incluye la librería Irrlicht porque los eventos se van a interceptar por medio de kbhit().
78
#define SERVER_PORT 60000 RakPeerInterface *peer; int main(void) { char str[512]; Packet *packet; peer = RakNetworkFactory::GetRakPeerInterface(); peer->Startup(1,30,&SocketDescriptor(), 1);
Se solicita al usuario que indique la dirección IP del Servidor o que presione ENTER para 127.0.0.1. printf("Ingrese la dirección IP del Servidor o ENTER para 127.0.0.1\n"); gets(str); if (str[0]==0){ strcpy(str, "127.0.0.1"); } printf("Iniciando el Cliente.\n"); peer->Connect(str, SERVER_PORT, 0,0);
La variable key va a guardar la tecla presionada por el usuario, se crea también un objeto de tipo Message para envíar los datos al servidor y dos variables que guardan la posición del cubo en el servidor en el plano XZ. unsigned char key=0; Message m; float X=0, Z=0;
La variable conectado indica si el Servidor ya ha aceptado o no la solicitud de conexión. Una vez acepatada la conexión se guarda la dirección del servidor en el objeto servidor y se interceptan los eventos de teclado. bool conectado = false; SystemAddress servidor; while (1) { if(kbhit() && conectado) { key = getch(); if(key==27) { //salir del programa break; }else if(key=='w') { //Hacia adelante m.ID = ID_MOVE; Z+=5; } else if (key=='s'){ //Hacia atrás m.ID = ID_MOVE;
79
Z-=5; } else if (key=='d'){ //Hacia la derecha m.ID = ID_MOVE; X+=5; } else if (key=='a'){ //Hacia la izquierda m.ID = ID_MOVE; X-=5; } else if (key=='r'){ //Cambiar la dirección de rotación m.ID = ID_ROTATE; printf("Cambiar rotación.\n"); }
Una vez definidos los valores de X, Z y m.ID se envía la estructura al servidor. Para envíar cualquier estructura basta con una conversión forzada a char * para manejarla como una secuencia de bytes: (char *)&m;
m.x = X; m.z = Z; peer->Send( (char *)&m, sizeof(m), HIGH_PRIORITY, // PacketPriority RELIABLE_ORDERED, // PacketReliability 0, // orderingChannel servidor, // systemAddress false // broadcast (true) );
Imprimir la nueva posición del cubo. printf("Desplazar: X=%.2f, Z=%.2f\n", X, Z); }
Se reciben los paquetes desde el servidor (si los hay). packet=peer->Receive(); while(packet) { switch (packet->data[0]) { case ID_REMOTE_DISCONNECTION_NOTIFICATION: printf("Otro cliente se ha desconectado.\n"); break; case ID_REMOTE_CONNECTION_LOST: printf("Otro cliente ha perdido la conexión.\n"); break; case ID_REMOTE_NEW_INCOMING_CONNECTION: printf("Otro cliente se ha conectado.\n"); break; case ID_CONNECTION_REQUEST_ACCEPTED: printf("Nuestra conexión ha sido aceptada.\n"); conectado = true;
80
servidor = packet->systemAddress; break; case ID_NO_FREE_INCOMING_CONNECTIONS: printf("El Servidor está lleno.\n"); break; case ID_DISCONNECTION_NOTIFICATION: printf("Hemos sido desconectados.\n"); break; case ID_CONNECTION_LOST: printf("Se perdió la conexión.\n"); break; default: printf("Nuevo mensaje con id: %i.\n", packet->data[0]); break; } peer->DeallocatePacket(packet); // Permanecemos en el ciclo hasta que no haya más paquetes. packet = peer->Receive(); } }
Por último se libera la interfaz de comunicación. La figura 3.4 muesta la aplicación en ejecución. RakNetworkFactory::DestroyRakPeerInterface(peer); return 0; }
Figura 3.4. Una muestra de la aplicación en ejecución. Atrás se puede ver la ventana del Servidor
con el cubo en rotación. La consola muestra los desplazamientos que han sido enviados al
servidor.
81
Capítulo IV
Aplicación: irrArena
IrrArena es un juego de primera persona que utiliza Irrlicht y RakNet. Se pueden cargar diversos escenarios de Quake 3 y también diferentes personajes utilizando modelos MD2. También incorpora irrKlang para manejo de audio 2D y 3D. Esta figura muestra el logotipo del juego.
82
83
4.1 Introducción Este capítulo presenta el diseño completo del juego de video de primera persona, en red y utilizando Irrlicht y RakNet. irrArena es un pequeño juego de acción de primera persona inspirado en el juego Quake 3 Arena de Id Software. El objetivo del juego es moverse a través de todo el escenario o campo de batalla eliminando a los demás jugadores. Cada jugador controla a su personaje a través de una computadora conectada al Servidor Arena, el cual refleja las acciones de cada jugador a las otras computadoras que ejecutan el programa Cliente en la red. Cuando el nivel de vida de un jugador llega a cero éste es reubicado en el escenario (conservando sus municiones) y el jugador que le ha eliminado suma un punto en el conteo de eliminados. El juego termina cuando uno de los jugadores alcanza el límite de enemigos eliminados especificado en la configuración del servidor. Tanto el Cliente como el Servidor son configurables por medio de los archivos config.xml que se encuentran en el mismo directorio del ejecutable. En el caso del servidor pueden configurarse diferentes opciones, tales como: el número de enemigos eliminados para ganar la partida, el número máximo permitido de clientes, el puerto a utilizar y también se deben cargar los diferentes mapas de Quake 3 (archivos pk3). Para el cliente las opciones de configuración son: Dirección IP del Servidor, puerto, volumen de los efectos de sonido, configuración de video, lista de reproducción de audio (pueden agregarse diferentes archivos de mp3 para escuchar mientras juega), los modelos de los jugadores (md2) y el listado de mapas de Quake 3. 4.2 Características del Juego
• irrArena es un juego de acción de primera persona. • Multijugador: El juego solo funciona en red y con dos o más jugadores. • Gráficos 3D: Utiliza el Engine Irrlicht para todo lo relacionado con el manejo de
gráficos 3D, cámaras, escenarios, modelos, etc. • Audio 2D y 3D: Utilizando el motor de audio irrKlang se reproducen diferentes
sonidos en 2D (tal como música de fondo) y 3D (por ejemplo, los pasos de otro jugador que se acerca hacia (o que se aleja de) el oyente o jugador).
• Configurable: El juego es configurable por medio de archivos XML. Se pueden cambiar ciertos valores como la gravedad y velocidad de salto del jugador para cada mapa. También se pueden añadir nuevos escenarios y modelos al juego, elegir el manejador de video (Direct3D, OpenGL, Software…), modo de pantalla completa o ventana, etc.
84
4.3 Instalación y puesta en marcha del juego En el CD que acompaña a este texto se incluye tanto el código fuente de la aplicación como los binarios. En esta sección se describe la configuración del juego e instalación de los binarios del juego. En el directorio Capítulo IV/bin hay dos directorios más, cliente y servidor. Se debe copiar la carpeta "Servidor" a la computadora de la red que se desea utilizar para servidor y la carpeta "Cliente" a cada computadora donde se va a ejecutar un cliente o instancia del juego. Se ejecuta "ServidorArena.exe" en el servidor, se selecciona un mapa (utilizando el número que lo identifica) y en cada cliente se ejecuta "arena.exe" y se selecciona un jugador (también por medio del número que lo identifica). 4.3.1 TECLAS UTILIZADAS PARA JUGAR Las teclas utilizadas para jugar son las siguientes: Movimiento: W - Caminar hacia adelante S - Caminar hacia atrás A - Caminar hacia la izquierda D - Caminar hacia la derecha BARRA ESPACIADORA - Saltar Información: I - Información de municiones y vida del jugador L - Listado de jugadores conectados a la partida Reproducción de audio: NUM * - Play / Pause NUM / - Siguiente canción NUM - - Bajar volumen NUM + - Subir volumen Acción: CTRL IZQ - Risa BACKSPACE - Suicidio Clic izquierdo - Disparar Salida: Para salir del juego se utiliza la tecla ESC.
85
A continuación se tratará acerca de la configuración del cliente y del servidor. El juego ya viene preconfigurado por lo que no necesita crear estos archivos manualmente. Si Ud. quiere modificarlos, por ejemplo para jugar en pantalla completa, entonces revise ésta documentación. 4.3.2 CONFIGURACIÓN DEL SERVIDOR (CONFIG.XML) Ahora se analizará parte por parte la estructura del archivo de configuración del Servidor irrArena: config.xml. <?xml version="1.0" ?> <!--Archivo de configuracion del servidor irrArena--> <!--Cristian de Leon Ronquillo-->
Toda la configuración del juego se encuentra dentro de las etiquetas <config> y </config> <!--Configuracion del juego--> <config>
Se define el número de bajas que un jugador debe efectuar sobre los demás para ganar la partida. También el número máximo de conexiones y el puerto a utilizar. <!--El ganador es el primero en alcanzar este numero--> <max_muertes val="15" /> <!--maximo numero de conexiones aceptadas por el servidor--> <max_clientes val="30" /> <!--Puerto del servidor--> <puerto_srv val="60000" />
Solo resta agregar el listado de mapas y los puntos válidos de cada mapa. Estos puntos se utilizan en el servidor para ubicar / reubicar a los jugadores en el mapa de Quake 3. También se utilizan para posicionar las municiones y energía que los jugadores pueden recoger. Es importante notar que el id del mapa debe coincidir con el id definido en el archivo de configuración del cliente, donde se definen otros valores como skyboxes29, gravedad, etc. <!--Configuracion de mapas, el id debe coincidir con el id del archivo de configuracion del cliente--> <mapa id="0" nombre="Return to Castle"> <!--Listado de puntos validos dentro del mapa para cargar a los jugadores--> <punto id="0" x="-100" y="100" z="-100" /> <punto id="1" x="-366" y="100" z="-53" /> <punto id="2" x="200" y="245" z="830" />
29
Un skybox es un cubo de dimensiones muy grandes que se ubica alrededor del escenario y que contiene
seis texturas (una por cada lado) que simula el cielo en la escena.
86
<punto id="3" x="226" y="245" z="-290" /> <punto id="4" x="-571" y="245" z="-543" /> <punto id="5" x="-479" y="245" z="-48" /> <punto id="6" x="555" y="360" z="1061" /> <punto id="7" x="548" y="450" z="321" /> <punto id="8" x="545" y="450" z="-66" /> <punto id="9" x="-117" y="450" z="-59" /> </mapa> <mapa id="1" nombre="ChiropteraDM"> <punto id="0" x="-1500" y="35" z="-775" /> <punto id="1" x="-700" y="75" z="-2321" /> <punto id="2" x="100" y="-157" z="-1438" /> <punto id="3" x="-1277" y="-549" z="-1047" /> <punto id="4" x="-1050" y="-325" z="-1796" /> <punto id="5" x="-2163" y="-101" z="-976" /> <punto id="6" x="-1639" y="35" z="-1471" /> <punto id="7" x="-667" y="-545" z="-660" /> </mapa> <mapa id="2" nombre="unbalanced II"> <punto id="0" x="-1539" y="419" z="-1379" /> <punto id="1" x="-895" y="291" z="-884" /> <punto id="2" x="-1527" y="419" z="-1407" /> <punto id="3" x="-1143" y="355" z="-2335" /> <punto id="4" x="-798" y="-29" z="-2381" /> <punto id="5" x="-381" y="-93" z="-1375" /> <punto id="6" x="-917" y="99" z="-2034" /> <punto id="7" x="-682" y="99" z="-2205" /> </mapa> <mapa id="3" nombre="JUL18"> <punto id="0" x="-806" y="163" z="-1522" /> <punto id="1" x="-1613" y="163" z="-1444" /> <punto id="2" x="-1403" y="163" z="-775" /> <punto id="3" x="-1293" y="163" z="-1400" /> </mapa> </config>
4.3.3 CONFIGURACIÓN DEL CLIENTE (CONFIG.XML) Ahora se examinará la configuración del cliente. Al igual que el anterior, se coloca toda la configuración entre las etiquetas <config> y </config>
<?xml version="1.0" ?> <!--Archivo de configuracion del cliente irrArena--> <!--Cristian de Leon Ronquillo--> <!--Configuracion del juego--> <config>
87
Lo primero es definir la dirección IP del servidor y el puerto a utilizar. <!--IP / Hostname del servidor irrArena--> <IP_srv val="127.0.0.1" /> <!--Puerto del servidor--> <puerto_srv val="60000" />
Ahora se establece el volumen de los efectos de sonido del juego, tal como el sonido de los pasos de los jugadores, los disparos, la risa del jugador, etc. El volumen puede variar de 0.00 a 1.00. <!--Sonidos de los jugadores y efectos especiales de audio--> <sonidos volumen="0.8" />
En la configuración de video los parámetros son: • completa: 1=pantalla completa, 0=modo de ventana • anchura: Anchura en pixeles de la ventana (o modo de video si se activa pantalla
completa) • altura: Altura en pixeles de la ventana (o modo de video si se activa pantalla
completa) • profundidad: Bits de color; cantidad de colores = pow(2, profundidad) • driver: Manejador de video
1=Direct3D 9 2=Direct3D 8.1 3=Open GL 1.5 4=Software Renderer
<!--Configuracion de video--> <video completa="0" anchura="800" altura="600" profundidad="8" driver="1" />
También es posible configurar una lista de reproducción de audio. Esta lista se ejecutará mientras el juego esté en ejecución y es independiente en cada cliente. Los parámetros principales son: activa: 1=Inicialmente activa y 0=Inicialmente pausada. volumen: Volumen de las pistas de audio. Toma valores de 0.00 a 1.00 aleatorio: 1=Reproducción aleatoria, 0=Ejecutar pistas ordenadas por su id. <!-- Lista de reproducciOn de audio --> <lista_reproduccion activa="0" volumen="0.45" aleatorio="0" >
Las etiquetas ítem_audio permiten añadir pistas de audio, solo basta asignar un id numérico y la ubicación física del archivo de audio. Los formatos que se aceptan son wav, ogg, mp3, mod, xm, it, s3m y demás formatos aceptados por irrKlang. <item_audio id="0" archivo="./media/music/ich_will.mp3" />
88
<item_audio id="1" archivo="./media/music/drop_out.mp3" /> <item_audio id="2" archivo="./media/music/mutter.mp3" /> <item_audio id="3" archivo="./media/music/deeply_disturbed.mp3" /> <item_audio id="4" archivo="./media/music/toxicity.mp3" /> </lista_reproduccion>
La configuración de jugadores permite cargar modelos MD2 al juego. Las etiquetas <jugador> se colocan dentro de las etiquetas <jugadores> y </jugadores>. Se debe definir el archivo de textura, la escala del modelo, los sonidos, etc. Los parámetros de la etiqueta <jugador> son:
• id: int. Un entero que identifica al modelo • nombre: str. Descripcion del modelo • archivo: str. Modelo MD2 • textura: str. Textura del modelo • escala: float. Escala del modelo • quitar_y: float. Diferencia entre el punto de rotación del modelo y los pies del
mismo • snd_saltar: str. Archivo de audio a ejecutar cuando el jugador salta • snd_morir: str. Archivo de audio a ejecutar cuando el jugador sea eliminado • snd_reir: str. Archivo de audio a ejecutar para que el jugador exprese risa
<!-- Configuracion de jugadores --> <jugadores> <jugador id="0" nombre="Sydney" archivo="./media/models/sydney.md2" textura="./media/models/sydney.bmp" escala="1.2" quitar_y="35.0" snd_saltar="./media/sounds/jump_woman.wav" snd_morir="./media/sounds/death1.wav" snd_reir="./media/sounds/taunt_woman.wav" /> <jugador id="1" nombre="Tris" archivo="./media/models/tris.md2" textura="./media/models/tris1.pcx" escala="1.0" quitar_y="35.0" snd_saltar="./media/sounds/jump.wav" snd_morir="./media/sounds/death3.wav" snd_reir="./media/sounds/taunt_man.wav" /> </jugadores>
89
Por último se configuran los archivos de los mapas o niveles de Quake 3. Como ya se mencionó, el id debe coincidir con el id del archivo de configuración del servidor. Los atributos de cada etiqueta <mapa> son los siguientes:
• nombre: (str) descripcion del mapa • autor: (str) autor del mapa • archivo: (str) pk3 • bsp: (str) nombre del archivo bsp contenido en el pk3 • cielo: (str) nombre de los archivos para crear un skybox (sin incluir _ft, _bk, _up,
_lf...) • cielo_ext: (str) formato de las imagenes de skybox • velocidad_salto: (float) velocidad inicial de salto del jugador
Todas las etiquetas <mapa> deben ir dentro de <mapas> y </mapas>. <mapas> <mapa id="0" nombre="Return to Castle" autor="Michael <|3FG20K> Cook" archivo="./media/levels/map-20kdm2.pk3" bsp="20kdm2.bsp" cielo="dashsky" cielo_ext="tga" velocidad_salto="0.7" gravedad="-3.0" /> <mapa id="1" nombre="ChiropteraDM" autor="Alcatraz / Nunuk / Sock" archivo="./media/levels/chiropteraDM.pk3" bsp="chiropteradm.bsp" cielo="chiroptera" cielo_ext="jpg" velocidad_salto="0.6" gravedad="-3.0" /> <mapa id="2" nombre="unbalanced II" autor="acid" archivo="./media/levels/map-acid3dm7.pk3" bsp="acid3dm7.bsp" cielo="" <!-- No definido --> cielo_ext="jpg" velocidad_salto="0.8" gravedad="-3.0" /> <mapa id="3" nombre="JUL18" autor="Julek (Julian Traciak)" archivo="./media/levels/jul18.pk3"
90
bsp="jul18.bsp" cielo="gwiazdy" cielo_ext="jpg" velocidad_salto="0.6" gravedad="-3.0" /> </mapas>
Cerrar la configuración. </config>
Es importante hacer notar que el archivo de configuración del cliente es independiente en cada computadora en donde se ejecute una instancia de dicha aplicación, por ejemplo, puede ejecutarse el juego en pantalla completa en una computadora y en modo de ventana en otra o tener listas de reproducción diferentes en cada instancia del juego.
91
4.4 Diseño del juego Una buena forma de representar la lógica de un juego de video es por medio de un Diagrama de Estados. Este diagrama presenta las transiciones que ocurren de un estado a otro a causa de los eventos involucrados en la aplicación. A continuación se muestra el diagrama de estados del Servidor en la Figura 4.2. El servidor gestiona toda la comunicación entre los clientes, por medio del envío de eventos. El diagrama muestra una vista general del funcionamiento de la aplicación servidor.
Figura 4.2. Diagrama de Estados del servidor IrrArena, desarrollado por el autor.
92
La aplicación del cliente es más extensa porque además de manejar la comunicación con el servidor también controla todos los eventos de teclado y mouse, animaciones, sonidos, etc. En la Figura 4.3 se muestra el diagrama general del funcionamiento del servidor del videojugo IrrArena.
Figura 4.2. Primera parte del diagrama de estados del cliente IrrArena, desarrollado por el autor.
Continúa en la siguiente página.
93
Figura 4.2. (Continuación). Segunda parte del diagrama de estados del cliente IrrArena, desarrollado
por Cristian de León.
94
95
CONCLUSIONES 1. El Engine (o Motor de gráficos) Irrlicht 3D es una librería para manejo de gráficos de
tiempo real de alto rendimiento, de código abierto e independiente de la plataforma, escrita en C++ por Nikolaus Gebhardt. Su principal ventaja es la sencillez de uso que presenta. Por ejemplo, con unas pocas líneas de código se puede cargar un mapa de Quake 3, añadir luces dinámicas, interceptar eventos de teclado y ratón e incluso hacer uso de elementos GUI. Su diseño es completamente orientado a objetos y está muy bien estructurado y completamente documentado.
2. RakNet es una librería para manejo de red basada en UDP; presenta una amplia gama de características entre las que se puede mencionar su sistema de replicación de objetos (permite automáticamente crear, destruir, serializar y transmitir cualquier objeto), implementación de algoritmos para la comunicación segura, llamadas a procedimientos de forma remota, respuesta en tiempo crítico, etc. RakNet es utilizada principalmente para videojuegos, pero es independiente de la aplicación que se le quiera dar. Se puede utilizar en proyectos no-comerciales bajo la licencia Creative Commons “Reconocimiento-No comercial 2.5 Genérica”. En general es una librería bastante extensa y muy bien diseñada.
3. Al desarrollar un juego de video es sumamente importante realizar la planeación y
diseño del mismo. Los videojuegos son aplicaciones que generalmente tienen un alto grado de complejidad, se debe definir desde un principio el tema y el tipo de juego, las características que pretende implementar y los objetivos del mismo. El éxito de un juego de video depende en gran parte de la idea que lo origina. El desarrollo de videojuegos incluye mucho más que solo la lógica y programación, involucra a expertos en diversas materias, por ejemplo: artistas gráficos para diseñar los personajes, pantallas y escenarios, ingenieros de audio, programadores, diseñadores 3D para modelar los personajes, los entornos y otros. El juego presentado en este texto “irrArena” se centra principalmente en el área de diseño y programación y utiliza recursos de diferentes sitios de Internet como stocks de audio y mapas de Quake 3 de diversos autores.
96
97
GLOSARIO AES: En criptografía, Advanced Encryption Standard (AES), también conocido como Rijndael, es un esquema de cifrado por bloques adoptado como un estándar de cifrado por el gobierno de los Estados Unidos. Se espera que sea usado en el mundo entero y analizado exhaustivamente, como fue el caso de su predecesor, el Data Encryption Standard (DES). El AES fue anunciado por el Instituto Nacional de Estandares y Tecnología (NIST) como FIPS PUB 197 de los Estados Unidos (FIPS 197) el 26 de noviembre de 2001 después de un proceso de estandarización que duró 5 años. AES tiene un tamaño de bloque fijo de 128 bits y tamaños de llave de 128, 192 ó 256 bits. Fuente: http://es.wikipedia.org/wiki/AES
Alpha blending : Es la combinación del canal alpha con otras capas en una imagen con el objetivo de mostrar objetos translúcidos. El canal alpha es un canal adicional a los canales de color de 8 bits usado con cada píxel en una gráfica de 32 bits y puede representar hasta 256 niveles de transparencia. El color negro (0) y el blanco (255) representan imagenes completamente opacas y completamente translúcidas respectivamente, mientras las tonalidades de gris (1-254) representan niveles de transparencia. Fuente: http://www.pcmag.com/encyclopedia_term/0,2542,t=alpha+blending&i=37668,00.asp
Bilinear filtering : Es un método de filtrado utilizado para suavizar las texturas cuando son desplegadas en un tamaño diferente del tamaño real de la imagen.
Blitting (Bit blit) : Es una operación de gráficos de computadora en la cual varios patrones de mapas de bits son combinados en una sola imagen utilizando una operación raster (por ejemplo una operación AND entre matrices).
Cuádrica : (o superficie cuádrica) es una hipersuperficie D-dimensional representada por una ecuación de segundo grado en variables (coordenadas) espaciales. La ecuación normalizada para una cuádrica tridimensional (D = 3) centrada en el origen (0,0,0) es:
Algunas superficies cuádricas son: Elipsoide, esferoide, esfera, paraboloide elíptico, paraboloide circular, paraboloide hiperbólico, hiperboloide de una hoja, hiperboloide de dos hojas, cono, cilindo elíptico, cilindro circular, cilindro hiperbólico y cilindro parabólico. Fuente: http://es.wikipedia.org/wiki/Cu%C3%A1drica
Gouraud shading : Es un método usado en gráficos de computadora para simular la diferencia entre los efectos de color y de luz sobre la superficie de un objeto. Se llama así por su inventor el científico francés Henri Gouraud. Fuente: http://en.wikipedia.org/wiki/Gouraud_shading
Hash : (o función hash) Se refiere a una función o método para generar claves o llaves que representen de manera casi unívoca a un documento, registro, archivo, etc., resumir o identificar un dato a través de la probabilidad, utilizando una función hash o algoritmo
98
hash. Un hash es el resultado de dicha función o algoritmo. Una función de hash es una función para resumir o identificar probabilísticamente un gran conjunto de información, dando como resultado un conjunto imagen finito generalmente menor (un subconjunto de los números naturales por ejemplo). Varían en los conjuntos de partida y de llegada y en cómo afectan a la salida similitudes o patrones de la entrada. Una propiedad fundamental del hashing es que si dos resultados de una misma función son diferentes, entonces las dos entradas que generaron dichos resultados también lo son. Fuente: http://es.wikipedia.org/wiki/Funci%C3%B3n_hash
Mapa de luz (Lightmap) : Es una estructura de datos de luz 3D que contiene el brillo de superficies en un juego de video. Los mapas de luz son precalculados y usado para objetos estáticos. Quake fue el primer juego de computadora en utilizar mapas de luz para agilizar el proceso de renderizado evitando que los pisos se vean distorsionados. Fuente: http://en.wikipedia.org/wiki/Lightmap
Morph target animation : (también conocida como animación por vértices) Es un método de animación computarizada 3D que algunas veces es utilizado como una alternativa a la animación con esqueletos (skeletal animation). Estas animaciones son almacenadas como una serie de posiciones de los vértices de un objeto o modelo. En cada fotograma de animación los vértices se mueven a una posición diferente. Fuente: http://en.wikipedia.org/wiki/Morph_target_animation
Pixel Shader : Es un programa de sombreado, normalmente ejecutado en la unidad de procesamiento gráfico. Este añade efectos 3D de sombreado e iluminación por píxel en una imagen. Un pixel shader sirve para manipular un píxel, por lo general para aplicar un efecto sobre la imagen, por ejemplo, el realismo, bump maping, sombras, explosiones etc. Fuete: http://es.wikipedia.org/wiki/Pixel_Shaders
Roll-off : Es la atenuación de un filtro de frecuencia a paso bajo o a paso alto, que está definida generalmente como la frecuencia en la que la respuesta es reducida por -3 dB. Fuente: http://www.audioc.com/library1/glossary.htm
RSA: Es el sistema criptográfico con clave pública RSA, que es un algoritmo asimétrico cifrador de bloques, que utiliza una clave pública, la cual se distribuye (en forma autenticada preferentemente), y otra privada, la cual es guardada en secreto por su propietario. La clave pública se genera a partir de la clave privada. Una clave es un número de gran tamaño, que una persona puede conceptualizar como una cadena de bits o bytes. Cuando se quiere enviar un mensaje, el emisor busca la clave pública de cifrado del receptor, cifra su mensaje con esa clave, y una vez que el mensaje cifrado llega al receptor, éste se ocupa de descifrarlo usando su clave privada. Fuente: http://es.wikipedia.org/wiki/RSA
Serialización : (o marshalling en inglés) consiste en un proceso de codificación de un Objeto (programación orientada a objetos) en un medio de almacenamiento (como puede ser un archivo, o un buffer de memoria) con el fin de transmitirlo a través de una conexión en red como una serie de bytes o en un formato humanamente más legible como XML. La
99
serie de bytes o el formato pueden ser usados para crear un nuevo objeto que es idéntico en todo al original, incluido su estado interno. La serialización es un mecanismo ampliamente usado para transportar objetos a través de una red, para hacer persistente un objeto en un archivo o base de datos, o para distribuir objetos idénticos a varias aplicaciones o localizaciones. Fuente: http://es.wikipedia.org/wiki/Serializaci%C3%B3n
SHA: (Secure Hash Algorithm, Algoritmo de Hash Seguro) es un sistema de funciones hash criptográficas relacionadas de la Agencia de Seguridad Nacional de los Estados Unidos y publicadas por el National Institute of Standards and Technology (NIST). El primer miembro de la familia fue publicado en 1993 es oficialmente llamado SHA. Sin embargo, hoy día, no oficialmente se le llama SHA-0 para evitar confusiones con sus sucesores. Dos años más tarde el primer sucesor de SHA fue publicado con el nombre de SHA-1. Existen cuatro variantes más que se han publicado desde entonces cuyas diferencias se basan en un diseño algo modificado y rangos de salida incrementados: SHA-224, SHA-256, SHA-384, y SHA-512 (llamándose SHA-2 a todos ellos). Fuente: http://es.wikipedia.org/wiki/SHA
Shader : Un Shader es un conjunto de instrucciones gráficas destinadas para el acelerador gráfico, estas instrucciones dan el aspecto final de un objeto. Los Shaders determinan materiales, efectos, color, luz, sombra y etc. Fuente: http://es.wikipedia.org/wiki/Shader
Skeletal animation: Es una técnica utilizada en animación por computadora, particularmente en la animación de vertebrados en la cual un modelo es representado en dos partes: Una representación de la superficie utilizada para dibujar el modelo (llamada piel) y un conjunto jerárquico de huesos utilizados únicamente para la animación (Llamado el esqueleto). Esta técnica es usada para construir una serie de "huesos", en la que cada uno tiene una transformación tridimensional (que incluye su posición, escala y orientación), y opcionalmente un hueso padre. Estos huesos forman una jerarquía. La transformación completa de un nodo hijo (hueso) es el producto de la transformación de su nodo padre y su propia transformación. De esta forma, por ejemplo, moviendo el hueso superior de la pierna de un modelo, la parte inferior de la pierna también se moverá. Conforme el modelo es animado, los huesos cambian su transformación en el tiempo, bajo la influencia de un controlador de animación. Fuente: http://en.wikipedia.org/wiki/Skeletal_animation
Stencil buffer : Es un buffer extra, en adición al buffer de color (pixel buffer) y el buffer de profundidad (z-buffering) que se encuentran en el hardware moderno de gráficos por computadora. El buffer está por píxel y trabaja en valores enteros, usualmente con una profundidad de un byte por píxel. La profundidad del buffer y el stencil buffer a menudo comparten un área de la memoria del hardware de gráficos. En el caso más simple, el stencil buffer es utilizado para limitar el área de renderizado (stenciling). Otros usos mas avanzados del stencil buffer hacen uso de la amplia conexión entre el buffer de profundidad (depth buffer) y el stencil buffer en el pipeline de renderizado (por ejemplo, los valores del stencil o troquel (área delimitada de dibujo) pueden ser automáticamente incrementados/decrementados por cada píxel que falló o pasó la prueba de profundidad).
100
La simple combinación de la prueba de profundidad y el modificador de stencil permiten un gran número de efectos posibles (tal como sombras, dibujo de siluetas o alta iluminación de intersecciones entre formas complejas) aunque éstas a menudo requieren múltiples procesos de renderizado y por consiguiente añaden una pesada carga de trabajo al hardware de gráficos. La aplicación más común sigue siendo la de añadir sombras para aplicaciones 3D. Esto también es utilizado para reflejos en planos. Fuente: http://en.wikipedia.org/wiki/Stencil_buffer
Streaming : Es un término que se refiere a ver u oír un archivo directamente desde internet sin necesidad de descargarlo antes al ordenador. Se podría describir como "hacer clic y obtener". En términos más complejos podría decirse que describe una estrategia sobre demanda para la distribución de contenido multimedia a través del internet. Fuente: http://es.wikipedia.org/wiki/Buffer%C3%A9o
SYN Cookies : Representan el elemento principal de una técnica utilizada para evitar ataques de inundación SYN (SYN Flood). El inventor de esta técnica es Daniel J. Bernstein. Las SYN Cookies evitan que el servidor descarte las conexiones cuando la cola SYN está llena. En lugar de eso, el servidor se comporta como si la cosa SYN fuera ampliada. El servidor envía de regreso la respuesta apropiada SYN+ACK a los clientes y descarta el paquete de la cola. Fuente: http://en.wikipedia.org/wiki/SYN_cookies
SYN Flood Atack : Es un método de ataque en redes que consiste en que el atacante envía varios paquetes sin enviar el mensaje de acuse de recibo (ACK) de regreso al servidor. Por consiguiente, las conexiones permanecen abiertas y consumen recursos del servidor. Otro usuario en la red trata de conectarse al servidor, el cual deniega la conexión a causa de las otras muchas conexiones abiertas. Fuente: http://en.wikipedia.org/wiki/SYN_flood
UDP: (User Datagram Protocol) es un protocolo del nivel de transporte basado en el intercambio de datagramas. Permite el envío de datagramas a través de la red sin que se haya establecido previamente una conexión, ya que el propio datagrama incorpora suficiente información de direccionamiento en su cabecera. Tampoco tiene confirmación, ni control de flujo, por lo que los paquetes pueden adelantarse unos a otros; y tampoco se sabe si ha llegado correctamente, ya que no hay confirmación de entrega o de recepción. Fuente: http://es.wikipedia.org/wiki/UDP
Vertex Shader : Es una herramienta capaz de trabajar con la estructura de vértices de los modelos tridimensionales y con ello realizar operaciones matemáticas modificando estas variables y así definiendo colores, texturas y incidencia de la luz. Esto da libertad a los programadores para realizar diferentes efectos desde la deformación de un objeto hasta la recreación de las olas del mar. En caso de representaciones gráficas de pelo se basaría en los vértices de la malla dando un efecto más realista al resultado. Con lo que conlleva una rápida ejecución de la imagen puesto que se utiliza el hardware especifico, en este caso el de las tarjetas gráficas. Fuente: http://es.wikipedia.org/wiki/Vertex_Shaders
101
BIBLIOGRAFÍA 1 Bourg , David M. 2002. Physics for Game Developers. USA: Editorial O’reilly &
Associates, Inc.
2 Cplusplus.com. Standard Template Library Reference. En línea:
http://www.cplusplus.com/reference/stl/
3 Diversos autores. Irrlicht3D Engine Wiki. En línea: http://www.irrlicht3d.org/wiki/
4 Gebhardt, Nikolaus. Irrlicht3D Tutorials. En línea:
http://irrlicht.sourceforge.net/tutorials.html
5 Gebhardt, Nikolaus.2008. Irrlicht3D Engine API Reference. En línea:
http://irrlicht.sourceforge.net/docu/index.html
6 Grossman, Stanley I. 1996. Algebra Lineal. Mèxico: Editorial McGraw-Hill.
7 Jenkins Software. Manual de programación con RakNet. En línea:
http://www.jenkinssoftware.com/raknet/manual/index.html
8 Microsoft. Matrices y Transformaciones, Microsoft DirectX 8.0 Programmer’s
Reference. Traducción en línea:
http://idam.ladei.org.ar/Tutoriales/Direct3D/Intro_MatTransf.html.
9 Millington, Ian. 2007. Game Physics Engine Development. USA: Morgan
Kaufmann Publishers.
10 Nakos, George y Joyner, David. 1999. Álgebra Lineal con Aplicaciones.
México: Editorial Thomson.
102
103
APÉNDICE A
Licencia de Irrlicht3d 30 LICENSE
The license of the Irrlicht Engine is based on the zlib/libpng license, only the name and the authors name have been replaced. Even though this license does not require you to mention that you are using the Irrlicht Engine in your product, an acknowledgement would be highly appreciated.
Please note that the Irrlicht Engine is based in part on the work of the Independent JPEG Group and the zlib. This means that if you use the Irrlicht Engine in your product, you must acknowledge somewhere in your documentation that you've used the IJG code. It would also be nice to mention that you use the Irrlicht Engine and the zlib. See the README files in the jpeglib and the zlib for further informations.
Irrlicht Engine License
The Irrlicht Engine License
Copyright © 2002-2005 Nikolaus Gebhardt
This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
30
Texto original de la licencia: http://irrlicht.sourceforge.net/license.html
104
LICENCIA
La licencia31 del Engine Irrlicht está basada en la licencia de zlib/libpng, únicamente el nombre y los autores han sido reemplazados, incluso aunque esta licencia no requiere que usted mencione que está utilizando el Engine Irrlicht en su producto, mencionarlo sería sumamente apreciado.
Por favor note que el Engine Irrlicht está basado en parte en el trabajo del Grupo Independiente JPEG y zlib. Esto significa que si Ud. utiliza el Engine Irrlicht en su producto, debe mencionar en algún lugar de su documentación que ha usado el código de IJG (Independent JPEG Group). También sería apreciado que mencione que está usando el Engine Irrlicht y zlib. Vea el archivo README incluido en jpeglib y zlib para mayor información al respecto.
Irrlicht Engine License
La licencia del Engine Irrlicht
Derechos Reservados © 2002-2005 Nikolaus Gebhardt
Este software se provee 'como-está', sin ninguna garantía implícita o expresa. Por ningún motivo los autores se harán responsables por ningún daño causado por éste software.
Se concede permiso de usar este software para cualquier propósito, incluyendo aplicaciones comerciales, libre modificación y redistribución del mismo, sujeto bajo las siguientes restricciones:
1. El origen de este software no puede ser alterado; usted no puede reclamar haber escrito el software original. Si usted utiliza este software en una aplicación, mencionarlo en la documentación del producto sería apreciado pero no es requerido.
2. Las versiones alteradas o modificadas del código fuente de este software deben ser expresamente marcadas como tal, y no pueden ser presentadas como el software original.
3. Esta nota no debería ser alterada o eliminada de ninguna distribución de este software.
31
Traducción realizada por el autor.
105
APÉNDICE B
Contribuciones y Recursos
Irrlicht 3D Engine: Motor de gráficos 3D de tiempo real.
http://irrlicht.sourceforge.net/
RakNet: Librería para manejo de red.
http://www.jenkinssoftware.com/
IrrKlang: Librería para manejo de audio 2D y 3D
http://www.ambiera.com/irrklang/
irrXML: XML parser
http://www.ambiera.com/irrxml/
Mapas de Quake 3 : Varios mapas incluídos en el ejemplo fueron descargados de
lvlworld.com
http://lvlworld.com/
Sonidos y modelos MD2:
Varios sonidos del juego de ejemplo fueron extraídos del juego Quake 3 Arena y el
personaje Tris y el arma utilizada fueron extraídos del juego Quake 2. Tanto los juegos
Quake 2 como Quake 3 han sido liberados por sus autores bajo la licencia GNU GPL.
http://cristiandlr.blogspot.com
106
107
APÉNDICE C
CONTENIDO DEL CD
El CD que acompaña a este material incluye todos los ejemplos como proyectos
de Visual Studio 2005 además de los instaladores necesarios para ejecutar dichas
aplicaciones. La estructura de directorios es la siguiente:
Videojuegos3D.pdf Este documento en formato pdf Capítulo II* LEAME.TXT Sección 2.3* Proyecto Sección 2.4* Proyecto Sección 2.5* Proyecto Sección 2.6* Proyecto Sección 2.7* Proyecto Sección 2.8* Proyecto Sección 2.9* Proyecto Capítulo III* LEAME.TXT Sección 3.4* Proyecto Sección 3.5* Proyecto Capítulo IV* LEAME.TXT Arena source* id_msg.h Cabecera compartida por ambos proyectos cli y srv cli* Proyecto srv* Proyecto imagenes* Algunas imagenes hechas para el juego (jpg, Freehand y psd) diagramas* Diseño del juego (formatos jpg y SmartDraw) bin* INSTALAR.TXT Cliente* Binarios irrKlang.dll DLL de irrKlang ikpMP3.dll MP3 config.xml XML de configuración del Cliente arena.exe Ejecutable del cliente media* Recursos del juego Servidor* config.xml XML de configuración del Servidor ServidorArena.exe
Los archivos LEAME.TXT situados dentro de cada directorio principal contienen
información detallada de cada uno de los proyectos incluidos.
*Directorio.