TFG I 1939
TFG I 1939
TFG I 1939
Departamento de Informática
Área de Ciencia de la Computación
e Inteligencia Artificial
2
ÍNDICE DE CONTENIDO
1. INTRODUCCIÓN .......................................................................................................9
1.1 Objetivos ........................................................................................................ 10
1.2 Visión general................................................................................................ 10
2. REALIDAD AUMENTADA...................................................................................... 11
2.1 Definición y funcionamiento ........................................................................ 12
2.2 Orígenes......................................................................................................... 14
2.3 Estado del arte .............................................................................................. 17
Aplicaciones en educación .................................................................................18
Aplicaciones en el arte ........................................................................................19
Aplicaciones en arquitectura ..............................................................................20
Aplicaciones en publicidad .................................................................................21
Aplicaciones en industria 4.0 ..............................................................................22
Aplicaciones médicas .........................................................................................24
Aplicaciones en entretenimiento ........................................................................25
2.4 Proyección de futuro .................................................................................... 26
2.5 Conclusiones ................................................................................................. 28
3. TECNOLOGÍA EMPLEADA ................................................................................... 29
3.1 Unity ............................................................................................................... 29
Interfaz .................................................................................................................31
3.2 Realidad aumentada en Unity ...................................................................... 37
3.3 El motor de realidad aumentada ARCore .................................................... 41
Conceptos fundamentales ..................................................................................42
4. DESARROLLO DE APLICACIONES EN UNITY ..................................................... 45
4.1 Preparación del Hardware ............................................................................ 45
Compatibilidad con ARCore ................................................................................45
Opciones de desarrollador y depuración por USB ..............................................46
4.2 Preparación del Software ............................................................................. 47
Descargar ARCore ...............................................................................................47
Descargar Unity ...................................................................................................47
4.3 Creación un proyecto en Unity ..................................................................... 50
4.4 Configuración inicial ..................................................................................... 50
4.5 GameObjects y Prefabs ................................................................................ 57
3
4.6 Elementos requeridos en la escena............................................................. 58
4.7 Configuración del SceneController .............................................................. 61
4.8 Detección y visualización de planos ............................................................ 62
4.9 Instanciación y manipulación de objetos .................................................... 63
4.10 Instalación de la Aplicación Base ................................................................ 69
5. APLICACIÓN DEMOSTRADOR ............................................................................. 71
5.1 Modelos 3D propios ...................................................................................... 71
5.2 Modelos con animaciones ........................................................................... 76
5.3 Cambios en el material del modelo ............................................................. 85
5.4 Mejoras en la interfaz ................................................................................... 89
5.5 Instalación de la Aplicación Demostrador .................................................. 99
5.6 Usabilidad .................................................................................................... 103
6. CONCLUSIONES ................................................................................................. 109
7. BIBLIOGRAFÍA..................................................................................................... 111
APÉNDICE 1: Código de la Aplicación Base .......................................................... 115
APÉNDICE 2: Código de la Aplicación Demostrador ............................................ 117
4
ÍNDICE DE FIGURAS
5
Figura 32. Activación de la Depuración USB. .......................................................... 46
Figura 33. Aplicación de Servicios de Google Play para RA. ................................. 47
Figura 34. Sección Installs en Unity Hub. ................................................................ 48
Figura 35. Ventana de elección de versiones de Unity Hub. .................................. 48
Figura 36. Ventana de selección de plataformas de Unity Hub. ............................ 49
Figura 37. Ventana de instalación de Visual Studio. .............................................. 49
Figura 38. Ventana de creación de proyecto en Unity Hub. ................................... 50
Figura 39. Instalación de paquetes. ......................................................................... 51
Figura 40. Configuración de reproductor necesaria. .............................................. 52
Figura 41. Configuración para que la aplicación soporte ARCore. ........................ 53
Figura 42. Configuración de calidad. ....................................................................... 53
Figura 43.Configuraciones de sombras. ................................................................. 53
Figura 44. Configuración del Gradle en Unity. ......................................................... 54
Figura 45. Configuración del JDK. ........................................................................... 56
Figura 46. Cuatro tipos diferentes de GameObject. ............................................... 57
Figura 47. Vista del inspector para ARCore Device. ............................................... 59
Figura 48. Vista del Inspector para First Person Camera. ..................................... 59
Figura 49. Vista del inspector para el Environmental Light.................................... 60
Figura 50. Vista del inspector para el SceneController. ......................................... 61
Figura 51. Vista del inspector para el PlaneGenerator. .......................................... 62
Figura 52. Vista del Inspector para el PlaneDiscovery. .......................................... 62
Figura 53. Vista del inspector para el ObjectGenerator.......................................... 67
Figura 54. Vista del inspector para el prefab Manipulator. .................................... 67
Figura 55. Objetos de juego secundarios del prefab Manipulator......................... 68
Figura 56. Vista del inspector para el ManipulationSystem. ................................. 68
Figura 57. Jerarquía de la aplicación base.............................................................. 69
Figura 58. Configuración de construcción para la aplicación base. ..................... 69
Figura 59. Ventana de instalación vía USB. ............................................................. 70
Figura 60. Vistas de la aplicación base en ejecución. ............................................ 70
Figura 61. Silla modelada en Blender. ..................................................................... 72
Figura 62. Ventana de exportación FBX en Blender. .............................................. 73
Figura 63. Vista del modelo importado en Unity. .................................................... 73
Figura 64. Vista completa del prefabricado del modelo. ....................................... 74
6
Figura 65. Vista de la silla en realidad aumentada. ................................................ 75
Figura 66. Silla de escritorio con animaciones en Blender. ................................... 76
Figura 67. Configuración para exportar animaciones en Blender. ........................ 77
Figura 68. Vista de la silla de escritorio importada en Unity. ................................ 77
Figura 69. Clips de animación en Unity. .................................................................. 78
Figura 70. Componente Animator para la silla de escritorio. ................................ 78
Figura 71. Animator Controller de la silla de escritorio. ......................................... 78
Figura 72. Vista inicial de la ventana Animator. ..................................................... 79
Figura 73. Vista final de la ventana Animator. ........................................................ 79
Figura 74. Vista del Inspector para el Canvas. ....................................................... 81
Figura 75. Modificación del texto de un botón. ...................................................... 82
Figura 76. Vista de Escena del Canvas en 2D. ........................................................ 83
Figura 77. Configuración On Click para la animación Rotar. ................................. 83
Figura 78. Materiales y texturas usados en la silla de escritorio. ......................... 84
Figura 79. Capturas antes y después de presionar el botón INCLINAR................ 84
Figura 80. Nuevos materiales para la silla de escritorio. ....................................... 85
Figura 81. Vista del Inspector para MaterialController. ......................................... 87
Figura 82. imágenes de las sillas tipo Sprite. ......................................................... 87
Figura 83. Componente Image de uno de los botones. ......................................... 87
Figura 84. Configuración On Click para cambiar a Tela Gris. ................................ 88
Figura 85. Capturas de la silla de escritorio con materiales diferentes................ 88
Figura 86. Nuevo diseño de los botones para los cambios de material. .............. 89
Figura 87. Configuración final On Click para cambiar a Tela Gris. ........................ 91
Figura 88. Parte inferior del Canvas definitivo. ....................................................... 91
Figura 89. Toggle Planes activado (izq.) y desactivado (dcha.)............................ 92
Figura 90. Configuración On Value Changed para el Toggle Planes. ................... 93
Figura 91. Variables públicas del DetectedPlaneGenerator. ................................. 94
Figura 92. Toggle EII activado (izq.) y desactivado (dcha.). .................................. 94
Figura 93. Configuración On Value Changed para el Toggle EII. ........................... 95
Figura 94. Imagen del mensaje inicial. .................................................................... 96
Figura 95. Animación para la imagen con el mensaje. .......................................... 97
Figura 96. Posición inicial (izq.) y final (dcha.) del mensaje. ................................ 97
Figura 97. Variables públicas del CanvasController. .............................................. 98
7
Figura 98. Configuración para identificación de la aplicación............................... 99
Figura 99. Iconos de las aplicaciones anteriores. ................................................ 100
Figura 100. Legacy Icons para la aplicación Demostrador. ................................. 100
Figura 101. Icono de la Aplicación Demostrador.................................................. 100
Figura 102. Configuración de la Splash Image. .................................................... 101
Figura 103. Vista de la pantalla de carga de la aplicación. .................................. 101
Figura 104. Capturas de la Aplicación Demostrador en funcionamiento. .......... 102
Figura 105. Gráfico de valoración SUS [49]. .......................................................... 107
8
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
1. INTRODUCCIÓN
En la época que vivimos podemos ver como muchas de las tecnologías que
surgieron hace décadas, prometiendo revolucionar por completo el mundo en que
vivimos, son ya una realidad. Algunos casos que nos son cercanos son los
teléfonos inteligentes, los ordenadores personales o el internet, que no solo se han
hecho un hueco en nuestras vidas, sino que muchos no podrían imaginarse la vida
sin ellos. Estas tecnologías han llegado para quedarse, al menos hasta que puedan
ser sustituidas por otras superiores.
Más en concreto, en el sector del diseño industrial, esta tecnología está destinada
a tener un papel importante, y no solo para el modelado 3D, sino también para la
comunicación de ideas. Su aplicación puede afectar a todo el proceso creativo
que hay detrás de un producto. Desde la concepción de la idea, pasando por el
prototipado y llegando hasta la presentación del producto final.
9 UNIVERSIDAD DE VALLADOLID
INTRODUCCIÓN
1.1 Objetivos
Teniendo en cuenta las necesidades antes mencionadas del diseño industrial, así
como las oportunidades que la realidad aumentada puede ofrecer, podemos
entender la motivación de este proyecto, que tiene como objetivos principales:
10
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
2. REALIDAD AUMENTADA
Sin embargo, en los últimos años, se han afianzado estrategias que combinan
ambos mundos, como la Realidad Mixta, que puede ser definida como el continuo
que va desde la realidad hasta la Realidad Virtual (simulaciones inmersivas de
ambientes reales), pasando por la Realidad Aumentada (representaciones de
entidades reales aumentadas con información digital) y la Virtualidad Aumentada
(mundos virtuales como videojuegos o Second Life, aumentados con
representaciones de entidades reales) [2].
11 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Por lo tanto, podemos definir la realidad aumentada como una tecnología que
integra señales captadas del mundo real (típicamente video y audio) con señales
generadas por computadores (objetos gráficos tridimensionales); las hace
corresponder para construir nuevos mundos coherentes, complementados y
enriquecidos [1].
12
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
13 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
2.2 Orígenes
Sería un error pensar que la Realidad Aumentada es una tecnología de naturaleza
reciente, pues ya en los años 90 el término era conocido y se utilizaba en distintos
campos que iban desde la Medicina, a la Aeronáutica, la Robótica y el Turismo.
Incluso podemos remontarnos más atrás en el tiempo. La primera concepción de
la Realidad Aumentada ocurrió en una novela de Frank L Baum escrita en 1901. En
ella incluyó la idea de unas gafas electrónicas que superponían datos sobre
personas que visualizaban, este invento era llamado “character maker” [8].
Años más tarde podemos encontrar otros casos como la conocida “Espada de
Damocles”, inventada en 1968 por el profesor de Harvard Ivan Sutherland.
Consistía en un artilugio que se colocaba sobre la cabeza (Head Mounted Display,
HMD) y mediante el cual el usuario podía experimentar gráficos generados por
ordenador [9]. En 1973, Ivan Sutherland inventará el casco de realidad virtual. Sin
embargo, estos inventos se acercan más a la realidad virtual que a la realidad
aumentada.
14
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
15 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Ya en el siglo XXI, según la empresa Innovae [6], que tiene amplia experiencia
creando experiencias de RA y RV, podemos clasificar el desarrollo de esta
tecnología en tres etapas.
Por último, consideramos que la tercera etapa comienza cuando entran en juego
las primeras gafas y visores RA. El primero que se promocionó a lo grande como
un dispositivo de Realidad Aumentada, fueron las Google Glass en 2012, que a
pesar del esfuerzo tecnológico no tuvo mucho éxito. Sin embargo, este fracaso
provocó que se comenzara a conocer de forma masiva esta tecnología.
16
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
17 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Aplicaciones en educación
Por otra parte, existen proyectos relacionados con el mundo de la química, como
el “Augmented Chemistry”, que enseña a los estudiantes un átomo o molécula RA
hasta que, al mover los marcadores, expone la reacción de seis ejemplos de
metales al mezclarlos con cuatro de soluciones [13].
18
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Aplicaciones en el arte
Otra de las disciplinas donde la realidad aumentada tiene una incidencia cada vez
mayor es el arte. Aquí podemos destacar “ARART”, que en palabras de sus
creadores “presenta una nueva plataforma de expresión que conecta la creación
artística con la realidad”. Una de sus funciones más populares es la animación de
pinturas. ARART permite que se desarrolle una nueva historia, como si el tiempo
atrapado dentro de la pintura hubiera cobrado vida. Ofrece un vistazo a la historia
oculta que se esconde detrás dl cuadro [15].
19 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Aplicaciones en arquitectura
Por último, “SmartReality”, que es una app similar a la anterior, pero que también
permite ver modelos en 3D creados a partir de elementos virtuales sobre planos
impresos. Además, se puede ver las distintas etapas de un proyecto, visualizar las
diferentes capas del diseño o grabar en vídeo su experiencia.
20
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Aplicaciones en publicidad
Una tienda de Nike en París ha utilizado la realidad aumentada de una forma muy
innovadora. A través dispositivos basados en la proyección, el cliente puede
personalizar las zapatillas a través de un ordenador, smatphone o tablet. Todos
los colores y diferentes patrones elegidos se proyectan sobre una zapatilla real
expuesta en el mostrador [17].
21 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Sin duda, la industria está siendo uno de los sectores en los que antes se está
adoptando la tecnología de realidad aumentada. Aplicaciones en ámbitos como el
mantenimiento, la fabricación, el marketing, la logística o la formación son ya
habituales en el mundo de la industria 4.0.
Una empresa pionera en el uso de la realidad aumentada es Airbus, que aplica esta
tecnología de múltiples formas. En 2019 comenzó una colaboración con Microsoft
para implementar su tecnología holográfica de RA y, de hecho, se llegaron a
identificar más de 300 casos de uso donde esta tecnología podría ser muy útil [18].
22
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
23 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Aplicaciones médicas
Por ejemplo, un cirujano podría tener información ampliada del paciente mientras
está realizando una operación. Incluso podría superponer su cuerpo unas guías
que le muestren por donde debe intervenir gracias al uso de imágenes médicas
con realidad aumentada (TAC, radiografía o resonancia magnética).
Una de las ventajas de mayor interés de las gafas de realidad aumentad para los
entornos quirúrgicos es la posibilidad de manejarlas con la voz y los gestos, por lo
que no sería necesario tocar nada.
24
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Aplicaciones en entretenimiento
Hoy en día ya son muchos juegos los que cuentan con la aplicación de la RA,
algunos pioneros basados en la ARToolKit (una biblioteca que permite la creación
de RA) como “AquaGaunglet”, “ARHockey” o “AR-Bowling”, entre otros muchos.
Pero sin duda, el ejemplo más destacado es “Pokémon GO”, que pulverizó todos
los récords de descargas en unos pocos días después de su lanzamiento.
Sin embargo, el futuro del entretenimiento pasa por el uso de elementos hardware
más inmersivos, como los HMD (Head Mounted Display), que por el momento no
son rentables debido a su alto coste. No obstante, siguiendo el camino en
innovación de las principales compañías desarrolladoras de videojuegos, es
posible que en una próxima generación de videoconsolas se incluyan ya estos
dispositivos, de forma que lleguen masivamente al público general.
Por otro lado, las retransmisiones deportivas son otro de los ámbitos en los que
podemos ver muchos ejemplos de la aplicación de la RA. Piscinas, campos de
fútbol, pistas de carreras o cualquier otro entorno deportivo puede ser preparado
fácilmente para el uso de esta tecnología.
25 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
Es difícil llegar a comprender hoy en día en qué medida nos va a cambiar la vida,
de aquí a unos años, la llegada de nuevas aplicaciones de realidad aumentada. Se
puede establecer un paralelismo con los profundos cambios que los teléfonos
inteligentes han traído a nuestra vida cotidiana: era imposible imaginarlos para la
generación de los 90.
26
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
llamada iOptik que proporcionará el paso crucial necesario para percibir vista
aumentada. Con estos lentes de contacto, el usuario puede ver el mundo natural,
sus ojos pueden moverse normalmente y no existen gafas pesadas para dificultar
el movimiento o la percepción [25].
Por otro lado, los sistemas de RA más actuales requieren de usuarios expertos
para operarlos, si las aplicaciones de realidad aumentada se convirtieran en
sistemas de usos comunes y frecuentes en las personas en su vida cotidiana,
entonces, los sistemas deberían ser cómodos, discretos, amigables y operables
por usuarios no expertos. Por lo tanto, se requiere de sistemas más robustos, que
eviten la calibración y los requisitos de configuración.
27 UNIVERSIDAD DE VALLADOLID
REALIDAD AUMENTADA
2.5 Conclusiones
Con todo lo visto en este capítulo hemos aprendido, en primer lugar, qué es lo que
se conoce como Realidad Aumentada y cuál es, a grandes rasgos, el
funcionamiento de esta tecnología. También hemos realizado un pequeño repaso
de sus orígenes, mostrando que, aunque se trata de un campo relativamente
nuevo, su investigación data ya de varias décadas atrás. Los avances tecnológicos
han provocado que en solo unos pocos años la RA se abra paso y se asiente como
una tecnología a tener en cuenta en cada vez más sectores. Por esta razón, se han
enumerado también varios ejemplos de su uso correspondientes a los principales
campos en los que la realidad aumentada tiene aplicación. Por último, se han
expuesto algunas de las líneas de investigación que con probabilidad se seguirán
en un futuro, orientadas a conseguir una mejor experiencia inmersiva y al alcance
de cada vez más sectores.
A pesar de las limitaciones con las que todavía cuenta, esta tecnología crece y se
innova constantemente, razón por la cual podemos suponer que la realidad
aumentada tiene un futuro prometedor y seguirá siendo por lo pronto un campo
recurrente de investigación en los próximos años.
Sin duda, en el ámbito del diseño industrial esta tecnología puede tener un gran
potencial, ya sea para facilitar tareas de diseño, para comunicar ideas o para
visualizar productos terminados de cara a la venta. Es esta la razón de ser del
presenta proyecto, que pretende poner a disposición de los diseñadores del
producto (principalmente) una herramienta con la que visualizar y exponer al
mundo sus propios productos.
28
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
3. TECNOLOGÍA EMPLEADA
3.1 Unity
29 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
▪ Puede usarse junto con Blender, 3ds Max, Maya, Softimage, Modo, ZBrush,
Cinema 4D, Cheetah3D, Adobe Photoshop, Adobe Fireworks y Allegorithmic
Substance. Si se realizan cambios en los modelos generados en cualquiera de
estos programas, todas las instancias de ese objeto se actualizan
automáticamente sin tener que volver a importarlo manualmente.
▪ El motor gráfico utiliza OpenGL (para los sistemas operativos Windows, Mac y
Linux), Direct3D (solo en Windows), OpenGL ES (para dispositivos con Android
y iOS), e interfaces propietarias (como la consola Wii). Tiene soporte para
mapeado de relieve, mapeado de reflejos, mapeado por paralaje, oclusión
ambiental en espacio de pantalla, sombras dinámicas utilizando mapas de
sombras, render a textura y efectos de post-procesamiento de pantalla
completa.
▪ Soporte integrado para Nvidia, el motor de física PhysX, (a partir de Unity 3.0)
con soporte en tiempo real para mallas arbitrarias y sin piel, ray casts gruesos,
y las capas de colisión.
▪ Incluye Unity Asset Server, una solución de control de versiones para todos los
assets de juego y scripts.
30
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Interfaz
31 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
Ahora que tenemos una visión general de la interfaz vamos a describir con mayor
detalle cada una de estas ventanas principales y algunas otras que también
utilizaremos.
Proyecto (Project)
Esta ventana muestra todos los archivos relacionados con nuestro proyecto. Es
un reflejo de las carpetas que lo constituyen y que se encuentran organizadas en
el ordenador. A través de ella podemos navegar y encontrar todos los activos
(assets) presentes en él, como escenas, scripts, modelos 3D, texturas, archivos de
audio y prefabricados.
El panel izquierdo muestra la estructura de carpetas del proyecto como una lista
de jerarquía. Cuando una carpeta es seleccionada de una lista, su contenido se
muestra en el panel a la derecha.
Los assets individuales aparecen en el panel de la mano derecha como iconos que
indican su tipo (script, material, subcarpeta, etc.). Los iconos pueden ser
redimensionados usando el deslizador que está en la parte inferior del panel. El
espacio a la izquierda del deslizador muestra el elemento actualmente
seleccionado, incluyendo una ruta completa al elemento si se está realizando una
búsqueda.
32
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Para poder trabajar de forma fluida dentro de esta vista es necesario poder
navegar por el espacio tridimensional de manera cómoda. En Unity existe un botón
de navegación en la esquina superior izquierda, representado por una mano.
Seleccionando esta herramienta tenemos tres estados diferentes:
También podemos posicionar nuestra cámara del visor de escena a través del
Gizmo que se encuentra en la parte superior derecha. Interactuando con él
podemos visualizar en todos los ejes de coordenadas e incluso cambiar entre dos
modos de visualización; perspectiva y ortográfica.
33 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
Dentro de esta ventana también existe una barra de control con varias opciones.
Entre otras cosas, permite modificar el aspecto con que se muestran los objetos
(Shaded, Wireframe, etc.), o cambiar entre una vista 3D y 2D.
34
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
En nuestro caso esta vista no nos será especialmente útil ya que, al tratarse de
una aplicación de realidad aumentada, la ventana no mostrará los resultados de
la cámara de nuestro dispositivo móvil y por ello aparecerá con un fondo azul. Sin
embargo, sí podemos visualizar elementos UI como botones.
35 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
36
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Otras ventanas
Las ventanas explicadas anteriormente nos sirven para comprender la interfaz
básica de Unity, sin embargo, existen algunas otras vistas que podemos utilizar
para tareas más específicas:
37 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
AR Foundation
AR Foundation incluye funciones centrales de ARKit, ARCore, Magic Leap y
HoloLens, así como funciones únicas de Unity, para crear aplicaciones robustas.
Este marco de trabajo permite aprovechar todas estas funciones en un flujo de
trabajo unificado [31]. Además, AR Foundation se puede integrar con Unity MARS.
Unity MARS
Unity Mars es una herramienta para creación de realidad aumentada en Unity que
permite la creación de apps inteligentes basadas en esta tecnología. Gracias a
esta solución se pueden llevar los datos del entorno y de los sensores al flujo
creativo, lo que permite la creación de apps inteligentes de AR que interactúen con
el mundo real mediante información virtual de cualquier tipo.
38
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Biblioteca Unity
Gracias a esta biblioteca se pueden integrar muchas funcionalidades y elementos
de Unity en las aplicaciones de realidad aumentada ya creadas, sin estar obligado
a reconstruir desde cero la aplicación. No solo nos permite añadir elementos de
realidad aumentada, sino también imágenes en 2D y 3D renderizadas en tiempo
real, minijuegos y mucho más [33].
XR Interaction Toolkit
Permite agregar funciones de interactividad a las apps de realidad aumentada en
Unity. De este modo, ya no es necesario tener que programar estas interacciones
desde cero [34].
Vuforia Engine
Se trata de un kit de desarrollo de software (SDK) para crear aplicaciones de
realidad aumentada. Los desarrolladores pueden agregar fácilmente
funcionalidad avanzada de visión por computadora a cualquier aplicación, lo que
permite reconocer imágenes y objetos e interactuar con espacios en el mundo
real. Admite el desarrollo de aplicaciones AR para dispositivos Android, iOS, Lumin
y UWP [35].
39 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
Unity Ads
Permite añadir anuncios o promociones a las apps de realidad aumentada con
Unity. Así se pueden crear campañas publicitarias originales que consigan un
mayor impacto de los clientes y contribuyan a mejorar la imagen de marca.
RA instantánea
Es un servicio especial de Unity que permite a los usuarios crear videojuegos o
contenidos de realidad aumentada que sean pequeños, rápidos y ligeros. Esta
plataforma todavía se encuentra en fase de desarrollo.
ARCore
Para el desarrollo de la aplicación del presente proyecto utilizaremos la plataforma
creada por Google para crear experiencias de realidad aumentada.
▪ AR Foundation:
Como se explicó anteriormente, es un marco multiplataforma que le permite
crear experiencias de realidad aumentada para dispositivos Android o iOS. En
este caso es necesario la instalación de las extensiones ARCore XR Plugin y
ARCore Extensions.
En este caso se ha elegido la segunda opción, es decir que trabajaremos con las
herramientas proporcionadas por el SDK para crear nuestra aplicación de realidad
aumentada. Más adelante se explicarán los pasos a seguir para descargarlo e
instalarlo en Unity.
40
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Esta interpretación del mundo real le permite colocar objetos, anotaciones u otra
información de una manera que se integra perfectamente en el entorno físico.
ARCore necesita que el móvil tenga instalado Servicios de Google Play para RA,
disponible en Google Play. No obstante, las aplicaciones que necesitan ARCore
pueden invocar su instalación. La ventaja de ser una API universal es que los
desarrolladores pueden usar sus funciones sin tener que crear su propia
implementación desde cero.
41 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
Conceptos fundamentales
Rastreo de movimiento
Para poder comprender cual es la posición del teléfono en relación con el mundo
que lo rodea, ARCore utiliza un proceso denominado localización y mapeo
simultáneos (SLAM) a medida que nuestro dispositivo móvil se mueve por el
mundo. Consiste en detectar características visualmente distintas en la imagen
capturada por la cámara llamadas puntos de características y usar estos puntos
para calcular el cambio en la ubicación. La información visual se combina con
mediciones inerciales de la IMU (Unidad de Medición Inercial) del dispositivo para
estimar la pose (posición y orientación) de la cámara en relación con el mundo a
lo largo del tiempo.
Comprensión ambiental
En el caso de intentar reconocer superficies planas sin texturas, como una pared
blanca, es posible que no ARCore no consiguiera detectarla ya que su tecnología
de detección de planos se basa en el reconocimiento de puntos característicos de
las superficies.
42
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Comprensión de profundidad
Estimación de luz
Imágenes aumentadas
Otra de las funciones de ARCore son las imágenes aumentadas, que permiten la
creación de aplicaciones de realidad aumentada que se activan a través de
imágenes 2D específicas. Los usuarios pueden generar experiencias de realidad
aumentada cuando apunten la cámara de su teléfono a determinadas imágenes.
ARCore también rastrea imágenes en movimiento como, por ejemplo, una valla
publicitaria en el costado de un autobús en movimiento. Las imágenes se pueden
compilar sin conexión para crear una base de datos de imágenes, o se pueden
agregar imágenes individuales en tiempo real desde el dispositivo. Una vez
registrado, ARCore detectará estas imágenes, los límites de las imágenes y
devolverá la pose correspondiente.
43 UNIVERSIDAD DE VALLADOLID
TECNOLOGÍA EMPLEADA
Puntos orientados
Anclas y rastreables
El hecho de que las poses puedan cambiar significa que ARCore puede actualizar
la posición de objetos ambientales como planos y puntos característicos a lo largo
del tiempo. Los planos y los puntos son un tipo especial de objeto llamado
rastreable. Como sugiere el nombre, estos son objetos que ARCore rastreará a lo
largo del tiempo. Se pueden anclar objetos virtuales a rastreables determinados
para asegurar que la relación entre el objeto virtual y el rastreable permanezca
estable incluso cuando el dispositivo se mueve. Esto quiere decir que, si se coloca
un modelo virtual en una mesa, si ARCore luego ajusta la posición del plano
asociado con la mesa, el modelo permanecerá encima de la mesa.
Intercambio
44
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
➢ https://developers.google.com/ar/devices
45 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Una vez que nos hemos asegurado de que nuestro dispositivo está certificado y
es compatible con ARCore, vamos a realizar algunos cambios en los ajustes de
éste.
▪ Android 9 (nivel de API 28) y versiones posteriores: Configuración > Acerca del
dispositivo > Número de compilación
▪ Android 8.0.0 (API nivel 26) y Android 8.1.0 (API nivel 26): Configuración >
Sistema > Acerca del dispositivo > Número de compilación
▪ Android 7.1 (nivel de API 25) y versiones anteriores: Configuración > Acerca del
dispositivo > Número de compilación
46
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Descargar ARCore
Descargar Unity
➢ https://unity3d.com/es/get-unity/download
47 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Dentro de Unity Hub, en la sección Installs podemos ver las versiones instaladas,
así como instalar otras a través del botón ADD. La versión con la cual se ha
realizado este proyecto es la 2019.4.19f1, que era la recomendada en el momento
de la instalación (LTS significa Long Term Suppport y son versiones de Unity a las
que se darán soporte durante al menos dos años).
48
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
49 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
En esta parte del tutorial explicaremos cuáles son las configuraciones que
deberemos establecer en nuestro proyecto para desarrollar una aplicación de
realidad aumentada con ARCore. Es decir, cuáles son los paquetes que debemos
instalar, cómo descargar e importar el SDK, los cambios a realizar en la
configuración del reproducción y en Gardle.
50
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Instalación de paquetes
Una vez en Unity procederemos a instalar algunos paquetes necesarios para
nuestra aplicación. Para ello iremos a Window > Package Manager, allí
buscaremos e instalaremos:
▪ XR Legacy Input Helpers, requerido para Instant Preview [43] (para obtener una
vista previa de la aplicación utilizando la entrada y salida real del dispositivo).
➢ https://github.com/google-ar/arcore-unity-sdk/releases/tag/v1.23.0
Para importarlo vamos a Assets > Import Package > Custom Package y
seleccionamos el archivo arcore-unity-sdk-1.23.0.unitypackage.
51 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
▪ En Minimum API Level seleccionamos Android 7.0 'Nougat' (API Level 24) u
otro superior.
52
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
53 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Para evitar este problema vamos a tener que personalizar el Gradle que Unity trae
por defecto. El proceso a seguir para llevar a cabo esta configuración depende de
la versión de Unity, como se explica en el siguiente enlace:
➢ https://developers.google.com/ar/develop/unity/android-11-build7
Aquí solo se recogen los pasos a seguir para las versiones 2019.3 y 2019.4.
De nuevo en Unity, vamos a Edit > Preferences > External Tools > Android,
desmarcamos la versión recomendada y seleccionamos la que hemos
descargado.
A continuación, vamos a Project Settings > Player > Android > Publishing Settings
> Build y seleccionamos:
Para finalizar vamos a modificar el código de estos dos archivos que se han
generado y que se encuentran en Assets/Plugins/Android dentro de la carpeta
donde esta guardado el proyecto.
54
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
buildscript {
repositories {
google()
jcenter()
}
dependencies {
// Must be Android Gradle Plugin 3.6.0 or later. For a list
of
// compatible Gradle versions refer to:
// https://developer.android.com/studio/releases/gradle-
plugin
classpath 'com.android.tools.build:gradle:3.6.0'
}
}
allprojects {
repositories {
google()
jcenter()
flatDir {
dirs 'libs'
}
}
}
55 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Este error puede deberse a que Unity no reconoce correctamente la ruta en la que
se encuentra ubicado el JDK que se ha instalado por defecto desde Unity Hub. La
solución es tan sencilla como ir a Edit > Preferences > External Tools > Android y
entonces desmarcar y volver a marcar la casilla de la opción que dice “JDK
installed With Unity”. De esta forma reconocerá la ruta correctamente y quedará
solucionado.
56
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Una vez que hemos configurado nuestro proyecto, como se explica anteriormente,
y hemos importado el SDK podemos empezar a crear la aplicación.
Para comprender mejor esto y, en general, la forma en que funciona Unity, vamos
a explicar dos conceptos que son fundamentales: los GameObjects y los Prefabs.
57 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
ARCore Device
En primer lugar, vamos a eliminar el objeto de juego Main Camera, ya que en su
lugar utilizaremos la cámara en primera persona del prefabricado ARCore Device.
58
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
59 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
ARCore Device contiene también otro objeto de juego, la First Person Camera, que
es su hijo dentro de la jerarquía. Este GameObject es la cámara principal dentro
de nuestra escena 3D.
Environmental Light
El segundo elemento que vamos a añadir será el Environmental Light, otro
prefabricado que además se encuentra en el mismo directorio que el anterior
(Assets/GoogleARCore/Prefabs). Debemos eliminar también el objeto de juego
Directional Light predeterminado.
Después, el script usa estos valores para generar un valor de intensidad de píxel
normalizado y establecer un valor de sombreado _GlobalColorCorrection. Además,
este script utiliza como variable una luz direccional que es un objeto hijo del
mismo prefabricado.
60
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
EventSystem
En tercer lugar, añadiremos el elemento EventSystem. En este caso no se trata de
un objeto prefabricado, sino que vamos a crearlo nosotros mismos desde el menú:
GameObject > UI > EventSystem.
Este tipo de objeto no tiene ninguna funcionalidad por sí mismo. Para que cumpla
su papel como controlador de escena vamos a agregarle un componente de tipo
C# script. Este script será el ObjectManipulationController que pertenece a la
escena ObjectManipulation del SDK, que es un ejemplo de aplicación muy similar
a lo que queremos conseguir con esta aplicación base. Podremos encontrarlo en
Assets/GoogleARCore/Examples/ObjectManipulation/Scripts.
61 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
En este apartado vamos a ver cómo podemos hacer para que nuestra aplicación
detecte los planos del entorno, ya sean verticales u horizontales, y, además,
podamos visualizarlos.
ARCore utiliza una clase llamada DetectedPlane para representar los planos
detectados. Esta clase no es un objeto de juego por sí mismo, sino que
necesitamos de un prefabricado para renderizar estos planos. Afortunadamente
en el SDK de ARCore para Unity contamos con un prefab de este tipo, llamado
DetectedPlaneVisualizer.
Para cada uno de los planos detectados, se creará un objeto de juego que
renderizará el plano usando el prefabricado DetectedPlaneVisualizer. Entre los
assets del SDK encontramos también un C# script denominado
DetectedPlaneGenerator.cs, que cumple con esta función.
62
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Este objeto de juego guía a los usuarios para escanear los alrededores y descubrir
planos. Consiste en una animación de una mano que sostiene un dispositivo móvil
e instrucciones breves que indican cómo moverlo para que se detecten puntos
característicos. Si no se encuentra ningún plano después de un cierto período de
tiempo, la barra de refrigerios muestra un botón que ofrece abrir una ventana de
ayuda con instrucciones más detalladas.
En esta parte del tutorial vamos a explicar por fin qué es lo que debemos hacer
para que nuestra aplicación sea capaz de generar instancias de un objeto,
colocándolo sobre un plano detectado y con la posibilidad de manipularlo con
entradas táctiles. Para ello necesitaremos añadir dos nuevos objetos de juego a
la escena: un generador de objetos que llamaremos ObjectGenerator, y un sistema
para controlar la manipulación del objeto, que será el prefab ManipulationSystem
del SDK.
ObjectGenerator
Este objeto de juego se encargará de gestionar la colocación del objeto en la
escena AR. Lo hará gracias a un script de manipulación que tendrá como
complemento. Este script tendrá referencias a la cámara en primera persona, al
prefabricado Manipulator del SDK y a al prefabricado del objeto que queramos
colocar.
63 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
namespace GoogleARCore.Examples.ObjectManipulation
{
using GoogleARCore;
using UnityEngine;
Ahora añadiremos una clase pública con el nombre del script seguido de la palabra
Manipulator, en vez de MonoBehaviour. De este modo estableceremos que la clase
hereda de la clase base Manipulator , que recibirá devoluciones de llamada de
ManipulationSystem cuando se detecten los diferentes gestos del usuario. En
estas devoluciones de llamada, Manipulator puede decidir si se inicia el gesto, qué
hacer mientras avanza y cuándo termina, anulando diferentes métodos de la clase
base.
return false;
}
64
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
En este caso, con TapGesture (es decir, un toque en la pantalla) crearemos una
instancia de un objeto desde el prefabricado en el momento en que el TapGesture
finaliza. Para ello introduciremos a continuación el método OnEndManipulation
(TapGesture gesture).
Dentro añadiremos, en primer lugar, las dos siguientes declaraciones lógicas if,
que forzarán la terminación de la ejecución del método en el caso de que el gesto
sea cancelado o que apunte a un objeto existente, respectivamente.
if (gesture.TargetObject != null)
{
return;
}
...
65 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Para limitar el número de instancias lo que haremos será imponer como condición
que el contador no sea mayor o igual al número de instancias deseadas. El
contador aumentará en una unidad cada vez que se generare un objeto nuevo.
TrackableHit hit;
TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon;
if (Frame.Raycast(
gesture.StartPosition.x, gesture.StartPosition.y, raycastFilter, out hit))
{
gameObject.transform.parent = manipulator.transform;
manipulator.transform.parent = anchor.transform;
manipulator.GetComponent<Manipulator>().Select();
}
}
Ahora debemos establecer un valor para las variables que hemos declarado como
públicas. Para añadir la cámara en primera persona simplemente podemos
arrastrarla desde la jerarquía hasta el espacio de la variable en el inspector. Por el
momento, como objeto prefabricado utilizaremos el modelo PawnPrefab del SDK
(Assets/GoogleARCore/Examples/Common/Prefabs), que nos servirá para
probar el funcionamiento de la aplicación base. El prefabricado Manipulator lo
podemos encontrar en la ventana de proyecto en Assets / GoogleARCore /
Examples / ObjectManipulation / Prefabs. Por último, vamos a fijar el número de
instancias en uno, para evitar crear objetos en el entorno por error al tocar la
pantalla.
66
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Como hemos explicado antes, la instancia del objeto se crea como hija del
ManipulatorPrefab. Este prefabricado contiene varios scripts manipuladores que
amplían la clase base Manipulator, y que anulan las funciones de llamada
anteriores para determinados tipos de gestos que en su lugar implementan
diferentes comportamientos a los que reacciona el objeto: selección, traslación,
escala, rotación y elevación. Algunos parámetros de estos scripts se pueden
personalizar abriendo el prefabricado en la ventana inspector.
67 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Por otra parte, al abrir el prefabricado veremos que, además de los scripts
mencionados, contiene dos objetos de juego secundarios: Selection Visualization
y Elevation Visualization. Los componentes tipo script SelectionManipulator y
ElevationManipulator hacen referencia a estos dos objetos de juego
respectivamente en el prefab Manipulator. La visualización de selección se
habilitará mientras el objeto está seleccionado, y la visualización de elevación se
habilitará mientras la manipulación de elevación esté activa.
ManipulationSystem
Por último, vamos a introducir en la escena el prefabricado ManipulationSystem
que encontraremos también entre los assets del SDK en Assets / GoogleARCore
/ Examples / ObjectManipulation / Prefabs.
Este prefab tan solo está formado por un componente de tipo C# script. Gracias a
la programación de este script se puede llevar a cabo la detección de las entradas
táctiles para después notificar a todos los manipuladores de la escena acerca de
estos gestos.
68
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
En primer lugar, vamos a guardar la escena a través del menú File > Save y la
nombraremos Aplicación Base. La jerarquía de nuestra escena debería quedar
como se ve en la siguiente imagen: los elementos ARCore Device,
EnvironmentalLight y EventSystem del apartado 5.2, el SceneController del 5.3, el
PlaneGenerator y PlaneDiscovery del 5.4, y, por último, el ObjectManipulator y
ManipulationSystem del apartado 5.5.
69 UNIVERSIDAD DE VALLADOLID
DESARROLLO DE APLICACIONES EN UNITY
Para comenzar a compilar la aplicación debemos pulsar el botón Build and Run,
que instalará la aplicación en nuestro teléfono y la ejecutará directamente. Antes,
Unity nos pedirá que guardemos el archivo .apk así que lo llamaremos también
“Aplicación Base” y le daremos a Guardar. En este momento comenzará la
compilación de la aplicación y cuando finalice, si todo funciona correctamente,
nos aparecerá una ventana en el móvil que nos preguntará si deseamos instalar la
ampliación vía USB, a lo que responderemos afirmativamente.
Tan solo tenemos que dar permiso para que utilice la cámara de nuestro
dispositivo (Figura 60 izq.) y ya podremos probar la aplicación. Si movemos el
teléfono veremos cómo empiezan a visualizarse los planos a los que apuntamos
con la cámara. Si realizamos un toque en la pantalla sobre un plano aparecerá el
objeto prefabricado, que también podremos trasladar y rotar (Figura 60 dcha.).
70
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
5. APLICACIÓN DEMOSTRADOR
En esta segunda parte del tutorial vamos a mejorar la aplicación base
implementando elementos que aportarán nuevas funcionalidades. En primer
lugar, aprenderemos a importar nuestros propios modelos 3D con sus propias
animaciones y materiales. Después veremos cómo activar las animaciones y
modificar los materiales mientras se ejecuta la aplicación. También realizaremos
una mejora de su interfaz y la instalaremos. Finalizaremos el capítulo con una
prueba para medir su usabilidad.
➢ https://docs.unity3d.com/es/530/Manual/HOWTO-importObject.html
71 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
más pequeños y que soporta otros paquetes 3D para cuyo formato propietario no
hay un soporte directo. Sin embargo, el segundo tipo de archivos también tiene
puntos positivos, como un proceso rápido de iteración (al guardar el archivo
fuente, Unity re-importa automáticamente) y la simplicidad en su uso.
En este apartado del tutorial vamos a trabajar con un modelo sencillo de una silla,
que ha sido creada en Blender. Por supuesto, el lector podrá utilizar el modelo 3D
y el programa de modelado que desee, siempre y cuando el modelo exportado se
encuentre en un formato compatible con Unity.
En este caso, como los archivos de Blender con compatibles con Unity, podríamos
arrastrarlo directamente a la ventana de proyecto. Sin embargo, vamos a importar
los modelos en Unity en formato FBX, que es un método más genérico ya que
estos archivos pueden ser generados por muchas de las aplicaciones de
modelado 3D. En este formato además del modelo podemos exportar cámaras,
luces, animaciones, rigs, etc. Las aplicaciones a menudo permiten exportar
objetos seleccionados o una escena entera.
72
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Ahora vamos a Archivo > Exportar > FBX (en Blender) y se abrirá una ventana con
opciones de exportación en la cual debemos asignar un nombre al archivo y elegir
dónde queremos guardarlo. Además, como la silla tiene asignados materiales con
texturas vamos a establecer la configuración de modo de rutas (Path Mode) en
Copiar y activamos la casilla de la derecha para incorporar las texturas, como se
ve en la siguiente figura.
Una vez exportado solo tenemos que ir al archivo y arrastrarlo hasta la ventana
proyecto de Unity. Cuando se complete la importación veremos que entre los
assets aparece nuestro modelo con una pestaña a la derecha, si la pulsamos se
desplegará y podremos ver todo lo que contiene el archivo FBX, en este caso todas
las piezas de la silla y los materiales.
También podemos ver que los materiales aplicados al modelo no tienen las
texturas que sí tenían en Blender. Para que se importen también estas texturas
tenemos que ir a las Import Settings (en el Inspector) y en Materials debemos
pulsar Extract Textures. En la ventana emergente seleccionamos la carpeta que
contiene esta escena, aunque también podemos crear otra nueva dentro para
guardar texturas y materiales. Veremos que las texturas se importan y se aplican
a nuestro modelo.
73 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Creación de un Prefab
Podríamos utilizar el modelo tal y como está ahora mismo, sin embargo, vamos a
añadir otro elemento que nos servirá para proyectar las sombras del modelo sobre
el plano en que se encuentra. Lo haremos a través de un prefab que contenga
tanto el modelo de la silla como un plano transparente.
Para ello vamos a crear en la Jerarquía un nuevo objeto de juego vacío con el
nombre “SillaPrefab”, que debe estar en la posición (0,0,0). Después arrastraremos
el modelo importado hasta el nuevo objeto para que sea su hijo.
Para crear el plano vamos a GameObject > 3D Object > Quad, lo llamamos
“ShadowQuad” y lo hacemos hijo igual que antes. Debemos orientarlo
horizontalmente, posicionarlo en el centro y escalarlo si hiciera falta. Para que el
plano sea transparente y se proyecten sombras sobre él vamos a asignarle un
material del SDK que se llama ShadowPlane y podemos encontrar en Assets /
GoogleARCore / Examples / Common / Materials.
Para que este objeto de juego que hemos creado se convierta en un prefabricado
simplemente debemos arrastrarlo hasta nuestros assets en la ventana Proyecto.
Ahora ya podemos eliminarlo de la Jerarquía y asignar el asset SillaPrefab como
la variable Object Prefab del script ObjectManipulator.
74
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Para este tutorial, como solo vamos a generar una instancia en la aplicación no
nos interesa visualizar constantemente el anillo de selección que teníamos en la
Aplicación Base. Por lo tanto, vamos a desactivar el script SelectionManipulator
del prefabricado Manipulator.
Antes de llevar a cabo la instalación (igual que en el apartado 5.6) vamos a guardar
la escena. También la agregamos a las escenas en construcción en Build Settings
y desmarcamos la escena de la Aplicación Base. Por último, en Player Settings >
Player y cambiamos el Product Name por “Modelos Propios”.
75 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora que ya sabemos emplear nuestros propios modelos 3D, vamos a empezar
a trabajar con animaciones, lo cual aumentará un poco el grado de complejidad
de la aplicación. El objetivo es aprender a importar modelos con sus propias
animaciones y activarlas mientras se ejecuta la aplicación a través de botones.
Para esta parte del tutorial vamos a utilizar otro modelo de ejemplo diferente. En
este caso se trata de una silla de oficina, que al igual que antes, ha sido modelada
en Blender. Esta silla es muy apropiada para animar ya que tiene varias partes
móviles que se pueden regular.
Para este modelo se han creado tres animaciones diferentes: en la primera la parte
superior realiza un giro de 360 grados sobre el eje de la silla, en la segunda se
acciona la palanca hacia arriba, el asiento se eleva y después vuelve a su posición,
y, por último, la palanca se acciona hacia afuera, el respaldo se reclina y retoma
también su posición original. Estas acciones se desencadenan una detrás de otra
con una duración total de 350 frames (fotogramas). Debemos recordar establecer
la frecuencia de fotogramas de Blender en 30 fps, que es como funciona Unity.
Una vez listo el modelo 3D podemos exportarlo en formato FBX, como hicimos
con la silla anterior. Ahora no es necesario incorporar las texturas, pero sí
debemos asegurarnos de que esté marcada la opción Capturar Animación y,
dentro de ella, estén desactivadas las tres primeras configuraciones. De este
modo las animaciones se guardarán en el archivo como una única animación
76
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
global y no se asignará cada animación a cada una de las partes del modelo.
Después nos encargaremos de dividir la animación como corresponde dentro de
Unity.
Antes de importar el nuevo archivo en nuestro proyecto, vamos a hacer una copia
de la escena como hicimos al comienzo del apartado anterior. En este caso la
llamaremos “Modelos Animados” y crearemos también una carpeta del mismo
nombre para almacenarla junto con los nuevos assets.
Para ello debemos fijarnos en las duraciones de las animaciones en Blender, por
ejemplo, nuestra primera animación va desde el fotograma 1 hasta el 90. Ahora
añadimos un clip a la lista, le asignamos un nombre y los fotogramas inicial y final
como corresponda. Debemos hacer lo mismo con el resto de las animaciones y
obtendremos una lista de clips como en la Figura 69. Finalmente, le daremos a
Apply y veremos que aparecen tres animaciones más entre los assets asociados
a nuestro modelo.
77 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora que ya tenemos el modelo y las animaciones listas vamos a crear un objeto
de juego prefabricado como hicimos con la silla del ejemplo anterior, añadiendo
igualmente un plano que reciba las sombras del objeto. El prefabricado se llamará
“SillaEscritorioPrefab”.
El componente Animator
Después abrimos el prefab desde la ventana Proyecto para agregarle un
componente Animator al modelo 3D. Este tipo de componentes son utilizados
para asignar una animación (o varias) a un GameObject dentro de la escena. Como
veremos, requiere una referencia a un Animator Controller que define qué clips de
animación usar, y controla cuándo y cómo mezclar y hacer una transición entre
estos.
Para crear este componente en la silla es tan sencillo como arrastrar los tres clips
de animación que hemos creado hasta el modelo dentro del prefabricado.
78
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
79 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
void FindObject()
{
instance = GameObject.Find("SillaEscritorio");
anim = instance.GetComponent<Animator>();
}
Después vamos a crear una función pública para cada animación. En este caso
serán tres, que denominaremos PlayRotar(), PlayElevar() y PlayInclinar(). Dentro
de cada una ellas, llamaremos a la función anterior FindObject() y después, se
activará la animación correspondiente.
80
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Una vez tenemos el script programado podemos pasar a estudiar cómo crear los
botones y hacer que activen las funciones que acabamos de crear.
Canvas
En primer lugar, vamos a crear un nuevo objeto de juego Canvas, que representa
un espacio abstracto en el cual los elementos UI (Interfaz de Usuario) son
colocados y renderizados. Todos los elementos de este tipo deben ser hijos del
Canvas. Para crearlo vamos al menú GameObject > UI > Canvas.
81 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora vamos a crear tres botones sencillos para activar nuestras animaciones.
Para ello vamos al menú GameObject > UI > Button y veremos que se crea
directamente como hijo del Canvas. Hacemos lo mismo para crear otros dos
botones y a cada uno de estos objetos de juego le asignamos el nombre de la
animación que van a activar.
Para cambiar el texto que aparece en el botón debemos acceder al objeto de juego
Text que es hijo suyo. En él podemos editar también otros aspectos como la
tipografía, el tamaño de letra, la alineación, el color, etc.
82
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
También podemos modificar otros parámetros del botón, sin embargo, no nos
detendremos en ellos puesto que tan solo necesitamos tres botones sencillos. Lo
que si haremos será posicionarlos en la parte inferior de la pantalla de forma
ordenada. Para visualizar mejor los elementos del Canvas es recomendable
activar la opción 2D de la ventana Escena.
Ahora ya solo nos falta asignarle una acción a los botones. En el componente
Button de los botones encontraremos una lista vacía con el título On Click (), que
lo que hace es invocar un evento cuando el usuario hace clic en el botón y lo suelta.
Añadiremos un elemento a la lista y arrastraremos el objeto InstanceAnimator
hasta el hueco disponible. Después, en la opción desplegable de la derecha
seleccionamos el script del objeto (InstanceAnimator) y la función que activa la
animación que corresponda.
Ahora ya tenemos programados los botones con las funciones que activan las
animaciones, pero antes de proceder a instalar la aplicación vamos a aplicarle
materiales a nuestro modelo.
83 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Añadiremos una carpeta nueva en la que almacenar los materiales e importar las
texturas (en el caso de que se usen). Para crear los materiales hacemos clic con
el Botón Derecho en la ventana proyecto y le damos a Create > Material. Para
aplicarlo solo hay que arrastrarlo hasta la parte del modelo deseada, ya sea en la
Escena o en la Jerarquía. La configuración de los materiales es muy similar a otros
programas de 3D, por lo que no se va a entrar en detalle.
84
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Al igual que en otras ocasiones, vamos a partir de la escena anterior, por lo que
haremos una copia de esta que llamaremos “Cambiar Material”. También
crearemos una carpeta con el mismo nombre para almacenar los nuevos assets.
Para esta parte del tutorial seguiremos utilizan el mismo objeto prefabricado con
la silla de escritorio, solamente cambiaremos los materiales de algunas de las
partes que la componen. La acción del cambio se llevará a cabo a través de
elementos UI, al igual que las animaciones.
En este ejemplo solo vamos a modificar las partes de la silla que originalmente
tenían un material de tela gris. Por lo tanto, en primer lugar, vamos a crear otros
dos materiales (Assets > Create > Material), uno será de cuero negro y otro de tela
azul, como se ve en la Figura 80.
Vamos a empezar a modificarlo partiendo del código por defecto que ya tiene el
script. En primer lugar, vamos a declarar tantas variables privadas de tipo
GameObject como partes del modelo queramos modificar y una matriz (array)
pública de tipo Material, tendrá un tamaño igual al número de materiales que
queramos utilizar, en este caso 3.
85 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Crearemos el método FindParts() donde vamos a buscar las partes del modelo a
las que queremos cambiar el nombre a través de su nombre y las almacenaremos
en las variables privadas que habíamos declarado, como se ve en el siguiente
código.
void FindParts()
{
cabecero = GameObject.Find("Cabecero");
lumbares = GameObject.Find("Lumbares");
asiento = GameObject.Find("Asiento");
}
86
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Ahora ya solo nos queda agregar al Canvas los elementos UI que activaran las
funciones del script anterior. En este caso vamos a utilizar también botones, pero
no contendrán texto, sino que serán imágenes de la silla con cada material
aplicado.
Después arrastramos cada imagen hasta la opción Source Image dentro del
componente Image de cada botón. Es recomendable que el tamaño de las
imágenes se ajuste al que tendrán en el Canvas, en este caso 250x250 pixeles.
87 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
A continuación, vamos a asignar las funciones a los botones como hicimos para
las animaciones en el apartado anterior. Arrastramos el objeto MaterialController
hasta un nuevo evento On Click() y buscamos en el script ChangeMaterial el
método que corresponda a cada botón.
88
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
En este punto del tutorial ya contamos con una aplicación totalmente funcional
para mostrar nuestros modelos de productos, con animaciones y cambios de
material. Por lo tanto, podríamos considerar que ya hemos alcanzado nuestros
objetivos, sin embargo, en este último apartado de la Aplicación Demostrador
vamos a mostrar cómo realizar algunas mejoras en su interfaz de cara a conseguir
una mejor experiencia de usuario.
Todos los cambios que realizaremos en este apartado serán aplicados sobre
elementos UI y no afectarán, en esencia, al funcionamiento de la aplicación, por lo
que podrían omitirse si así se desea.
En la Figura 86 podemos ver el aspecto de los nuevos botones. Al igual que los
demás, han sido diseñados en Adobe Illustrator y exportados como imágenes en
formato PNG, directamente con el tamaño que tendrán en el Canvas.
Figura 86. Nuevo diseño de los botones para los cambios de material.
Una vez importadas estas imágenes en Unity debemos establecer el Texture Type
en Sprite (2D and UI), como vimos en el apartado anterior. Después arrastramos
cada imagen al Source Image del botón correspondiente y los colocamos todos
en la misma posición en el Canvas. En este caso irán en la parte inferior de la
pantalla.
89 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora debemos programar estos botones para que se alternen y realicen los
cambios de material de manera correcta. Para ello vamos a crear un nuevo script
llamado CanvasController, que será un componente del Canvas. Lo haremos así
porque utilizaremos este mismo script para controlar también otros elementos UI.
Una vez abierto el script en Visual Studio vamos a empezar declarando cuatro
nuevas variables públicas: tres de tipo GameObject para los botones y otra de tipo
ChangeMaterial para el script del mismo nombre que configuramos en el apartado
anterior.
90
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Ahora son estas funciones del Canvas las que debemos asignar a cada uno de los
botones, en vez de las del MaterialController.
Con esta nueva distribución hemos conseguido concentrar todos los elementos
UI que teníamos en una zona, dejando suficiente espacio en el resto de la pantalla
para ver y manipular el modelo en tiempo de ejecución.
Los objetos de juego de este tipo contienen a su vez otros dos elementos que son
imágenes: el Backgroud y el Checkmark, siendo el segundo hijo del primero. El
Backgroud es el fondo del elemento y el Checkmark aparece y desaparece
dependiendo de si se encuentra activado o desactivado. En este caso se han
cambiado las imágenes del Toggle para conseguir un icono que represente la
función que ejerce. En la Figura 89 podemos verlo en sus dos estados y ubicado
en la parte superior derecha del Canvas.
91 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora, dentro del script vamos a añadir tres nuevas variables. Dos de ellas serán
públicas, de tipo material y que almacenaran el material transparente y que
contiene la malla triangular. La tercera variable será booleana, inicialmente
verdadera y nos servirá permitir o no la búsqueda de nuevos planos.
Después vamos a añadir una nueva función llamada OnTogglePlanes() con una
variable booleana de entrada llamada toggle, ya que cambiará de estado al
cambiar el del elemento UI. Dentro de esta función, en primer lugar, se establece
que la variable search es igual a toggle. Después, se buscan todos los objetos de
juego con la etiqueta “plane” y se almacenan dentro de una nueva variable del
mismo nombre. El material asignado a estos objetos será grid o transparent,
dependiendo del estado del toggle.
92
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
if (search)
{
Session.GetTrackables<DetectedPlane>(_newPlanes,
TrackableQueryFilter.New);
for (int i = 0; i < _newPlanes.Count; i++)
{
GameObject planeObject =
Instantiate(DetectedPlanePrefab, Vector3.zero,
Quaternion.identity, transform);
planeObject.GetComponent<DetectedPlaneVisualizer>().Initialize(_newPlanes[i]);
}
}
93 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
A continuación, vamos a añadir otro elemento toggle, que servirá para activar y
desactivar el resto de los elementos del Canvas. Lo que buscamos con esto es
ofrecer la posibilidad de realizar una captura de pantalla sin que existan elementos
UI que tapen una parte de la imagen. En este caso vamos a utilizar el logotipo de
la Escuela de Ingenierías Industriales, por eso lo llamaremos Toggle EII. Cuando
este toggle se encuentre desmarcado quedará como una pequeña marca de agua
con la forma del logo en la esquina superior izquierda.
94
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Ahora añadiremos una nueva función llamada OnToggleEII() con una variable
booleana de entrada llamada toggle, al igual que hicimos antes para el otro
elemento del mismo tipo. Dentro de esta función los elementos UI estarán
activados o desactivados dependiendo del valor de la variable booleana toggle.
Al igual que hicimos antes, tenemos que asignarle la función OnToggleEII del
CanvasController al elemento Toggle EII en la configuración On Value Changed
(Boolean).
Para terminar la aplicación realizar a hacer dos cambios más. En primer lugar,
haremos que el Canvas se active por primera vez justo en el momento en que se
instancia el modelo sobre un plano. Para ello, vamos a realizar algunas
modificaciones más en el script CanvasController.
En primer lugar, declararemos una nueva variable pública para el Toggle EII.
Después vamos a hacer que en la función Start() todos los elementos del Canvas
estén desactivados.
void Start()
{
botonTelaGris.SetActive(false);
botonTelaAzul.SetActive(false);
botonCuero.SetActive(false);
panelAnim.SetActive(false);
togglePlanes.SetActive(false);
toggleEII.SetActive(false);
}
95 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Ahora debemos realizar una llamada a esta función dentro del script
ObjectManipulator del ObjectGenerator. Para ello debemos declarar en él una nueva
variable para el script CanvasController.
...
var gameObject = Instantiate(ObjectPrefab, hit.Pose.position,
hit.Pose.rotation);
count++;
CanvasController.ActivateCanvas();
...
96
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Ahora debemos colocar la imagen fuera del Canvas, en la parte superior. Para
empezar a animar le damos al botón rojo (keyframe recording mode) de la ventana
Animation, nos ubicamos en el segundo 1:30 en la línea de tiempo, colocamos la
imagen en la posición correcta en el Canvas y le damos de nuevo al botón rojo
para dejar de grabar. Después, seleccionamos los keyframes (fotogramas clave)
que se han creado y los desplazamos en la línea temporal para que la animación
comience en el segundo 10. Finalmente, nos ponemos de nuevo en el segundo 0
y añadimos un nuevo keyframe (botón add keyframe).
97 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
Después, haremos que dentro de la función Start() este elementos sea el único
que se encuentra activo.
void Start()
{
...
imageMensaje.SetActive(true);
}
imageMensaje.SetActive(false);
}
Una vez hecho esto podemos guardar definitivamente el script (en el Apéndice 2
se puede encontrar el código completo del script).
98
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
En este último apartado del tutorial vamos a ver de nuevo cómo podemos instalar
nuestra aplicación, pero esta vez de una forma más detallada. Empezaremos
estableciendo una identificación correcta para la aplicación. Después veremos
cómo modificar el icono que la representa y la ventana de carga que aparece al
ejecutarla. Finalmente la instalaremos en nuestro dispositivo.
Identificación de la aplicación
Cuando instalamos una aplicación en nuestro dispositivo, esta tiene una serie de
características que la hacen única, es decir que la identifican. En el caso de existir
varias aplicaciones con la misma información que las caracteriza, el dispositivo
interpretará que son idénticas e instalará la más reciente, sobre escribiendo la
versión más antigua.
Ahora vamos a definir el nombre que identificará nuestra aplicación final. Para ello
iremos a las Player Settings y rellenaremos los tres primeros campos que
aparecen. En Company Name podemos poner las siglas de la escuela “EII”, en el
Product Name introduciremos el nombre “Demostrador AR” y la Versión podemos
mantenerla en 0.1.
Iconos
Otro de los aspectos característicos de nuestra aplicación que podemos modificar
es el icono con el que aparece representada en nuestro dispositivo. En las Player
Settings podemos encontrar una sección Icon donde podemos modificar los
iconos, que pueden ser de tres tipos: Adaptative, Round y Legacy. Los dos últimos
99 UNIVERSIDAD DE VALLADOLID
APLICACIÓN DEMOSTRADOR
tipos son para API 25 y versiones anteriores. Los iconos adaptativos son para API
26 y posteriores, y constan de dos partes: el fondo (backgroud) y el primer plano
(foregroud).
Si desplegamos la opción Legacy Icons, veremos que hay una imagen asignada
para las 6 resoluciones del icono. Esta imagen es la correspondiente al ejemplo
ObjectManipulation del SDK y es la que se ha aplicado a los iconos de todas las
aplicaciones que hemos instalado hasta ahora.
100
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
Pantalla de inicio
Cuando iniciamos una aplicación que ha sido creada en Unity, normalmente se
carga una pantalla de inicio que contiene el logotipo del programa. Esta pantalla
puede ser modificada en la sección Splash Image, también en las Player Settings.
Sin embargo, el nivel de personalización esta pantalla de presentación dependerá
de nuestra suscripción a Unity. En el caso de la suscripción a Unity Personal no
podremos desactivar por completo esta pantalla ni quitar el logotipo de Unity.
Podemos modificar varios aspectos como el Splash Style para que el logo se vea
claro sobre oscuro u oscuro sobre claro, el tipo de animación, añadir más logos, la
posición y duración de los logos, el fondo, etc.
Para esta aplicación tan solo vamos a añadir un nuevo logo, que será también el
de la escuela, pero esta vez en blanco, con el nombre de la aplicación y con
márgenes a ambos lados para que se ajuste bien al tamaño de la pantalla.
También vamos a cambiar el color de fondo por un azul muy parecido al del logo
de EII. El resultado de esta pantalla de inicio se muestra en la Figura 103.
Con esto ya tenemos totalmente lista nuestra aplicación para visualizar nuestros
propios modelos, con la posibilidad de manipularlos, animarlos, cambiar sus
materiales y, además, con una interfaz atractiva e intuitiva.
102
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
5.6 Usabilidad
La utilidad de un sistema, en tanto que medio para conseguir un objetivo, tiene una
componente de funcionalidad (utilidad funcional) y otra basada en el modo en que
los usuarios pueden usar dicha funcionalidad. Es esta componente la que nos
interesa ahora.
La efectividad se refiere la precisión y la plenitud con las que los usuarios alcanzan
los objetivos especificados.
Por otra parte, la aplicación aquí desarrollada, por su naturaleza, puede llegar a
ofrecer una gran versatilidad en su uso. Desde un principio fue orientada hacia el
mundo del diseño industrial. Fue concebida como una aplicación para mostrar
productos en realidad aumentada. Sin embargo, los usos de esta aplicación
pueden ser tantos como modelos 3D se quieran utilizar.
Prueba de usabilidad
En este apartado veremos cómo se ha llevado a cabo la valoración de la usabilidad
de la aplicación, así como los resultados obtenidos en la prueba.
Respecto a las condiciones de las pruebas de usabilidad cabe decir que se han
realizado de manera remota, poniendo a disposición de los usuarios el archivo
.apk de la aplicación. De esta forma se ha podido comprobar también que se
comporta de forma correcta en otros dispositivos Android. Además, se ha
aportado una explicación muy breve sobre el funcionamiento de la aplicación, sin
entrar en detalles para mantener la objetividad.
1. Creo que usaría esta aplicación para mostrar mis modelos 3D.
104
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
4. Creo que necesitaría ayuda de una persona con conocimientos técnicos para
usar esta aplicación.
106
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
10. Necesité aprender muchas cosas antes de ser capaz de usar esta aplicación.
Una vez que contamos con todas las respuestas del test podemos pasar a realizar
la medición. Para obtener los resultados, debemos seguir la siguiente pauta para
cada una de las respuestas al test: las preguntas impares (1,3,5,7 y 9) tomarán el
valor asignado por el entrevistado, y se le restará 1. Para las preguntas pares
(2,4,6,8,10), el valor será de 5 menos el valor asignado por los usuarios. Una vez
obtenido el número final, se lo multiplica por 2,5.
5, 1, 4, 1, 4, 1, 3, 1, 5, 1.
Debemos hacer lo mismo con los resultados de todos los usuarios y después
calcular la media de sus puntajes SUS. El máximo teórico de la escala es 100 y el
resultado medio de todos los entrevistados que se ha obtenido para nuestra
aplicación es de 93,25. Según el gráfico de la Figura 105 esta marca supera “lo
mejor imaginable” en lo que se refiere a la usabilidad de nuestro sistema.
108
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
6. CONCLUSIONES
Como conclusión, podría decirse que este proyecto es una toma de contacto con
la realidad aumenta, que ofrece los conocimientos para iniciarse en el estudio de
esta tecnología en general, y en particular, también aporta las herramientas para
la creación de aplicaciones en Unity basadas en experiencias de realidad
aumentada.
Que este trabajo pueda servir de base para otros estudiantes ha sido también otro
de los objetivos. La realidad aumentada tiene una gran proyección de futuro y,
aunque todavía queda mucho por investigar, son de esperar grandes avances en
los próximos años, que traerán consigo nuevas oportunidades para satisfacer
necesidades. Este continuo cambio debe motivarnos seguir progresando en el
desarrollo en esta tecnología, porque las posibilidades son inmensas y aún falta
mucho por crear.
110
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
7. BIBLIOGRAFÍA
[8] “Augmented Reality – The Past, The Present and The Future,” Interaction
Design Foundation (IxDF). https://www.interaction-
design.org/literature/article/augmented-reality-the-past-the-present-and-
the-future.
[18] “Airbus vuela más alto con ayuda de la tecnología de realidad mixta de
Microsoft,” Centro de noticias Microsoft. https://news.microsoft.com/es-
es/2019/06/18/airbus-vuela-mas-alto-con-ayuda-de-la-tecnologia-de-
realidad-mixta-de-microsoft/.
[21] B. Díaz, “Así funciona la realidad aumentada con la que Volvo desarrollará
sus vehículos,” Car and Driver, 2019.
https://www.caranddriver.com/es/coches/planeta-motor/a60364/volvo-
realidad-aumentada-desarrollo-vehiculos-seguridad/.
112
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
[27] “¿Qué es Unity y para qué puedo utilizarlo?,” IFP, Aug. 21, 2020.
https://www.ifp.es/blog/que-es-unity-y-para-que-puedo-utilizarlo.
[34] M. Fuad and M. Dalby, “XR Interaction Toolkit Preview Package is here,”
Unity Blog, Dec. 17, 2019. https://blog.unity.com/technology/xr-interaction-
toolkit-preview-package-is-here.
[38] I. Ramírez, “ARCore: qué es, para qué sirve y móviles compatibles,” xataka
android, Apr. 25, 2021. https://www.xatakandroid.com/realidad-
aumentada/arcore-que-sirve-moviles-compatibles.
114
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
namespace GoogleARCore.Examples.ObjectManipulation
{
using GoogleARCore;
using UnityEngine;
return false;
}
if (gesture.TargetObject != null)
{
return;
}
TrackableHit hit;
TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon;
if (Frame.Raycast(
gesture.StartPosition.x, gesture.StartPosition.y, raycastFilter, out hit))
{
var manipulator =
Instantiate(ManipulatorPrefab, hit.Pose.position,
115
hit.Pose.rotation); UNIVERSIDAD DE VALLADOLID
gameObject.transform.parent = manipulator.transform;
APÉNDICE 1: Código de la Aplicación Base
else
{
var gameObject = Instantiate(ObjectPrefab, hit.Pose.position,
hit.Pose.rotation);
count++;
var manipulator =
Instantiate(ManipulatorPrefab, hit.Pose.position,
hit.Pose.rotation);
gameObject.transform.parent = manipulator.transform;
manipulator.transform.parent = anchor.transform;
manipulator.GetComponent<Manipulator>().Select();
}
}
}
}
}
116
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
void FindObject()
{
instance = GameObject.Find("SillaEscritorio");
anim = instance.GetComponent<Animator>();
}
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
void FindParts()
{
cabecero = GameObject.Find("Cabecero");
lumbares = GameObject.Find("Lumbares");
asiento = GameObject.Find("Asiento");
}
118
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
imageMensaje.SetActive(true);
}
imageMensaje.SetActive(false);
}
120
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
namespace GoogleARCore.Examples.Common
{
using System.Collections.Generic;
using GoogleARCore;
using UnityEngine;
if (search)
{
Session.GetTrackables<DetectedPlane>(_newPlanes,
TrackableQueryFilter.New);
for (int i = 0; i < _newPlanes.Count; i++)
{
GameObject planeObject =
Instantiate(DetectedPlanePrefab, Vector3.zero,
Quaternion.identity, transform);
planeObject.GetComponent<DetectedPlaneVisualizer>().Initialize(_newPlanes[i]);
}
}
}
}
}
122
TRABAJO DE FIN DE GRADO
APLICACIÓN DE REALIDAD AUMENTADA
namespace GoogleARCore.Examples.ObjectManipulation
{
using GoogleARCore;
using UnityEngine;
return false;
}
if (gesture.TargetObject != null)
{
return;
}
TrackableHit hit;
TrackableHitFlags raycastFilter = TrackableHitFlags.PlaneWithinPolygon;
if (Frame.Raycast(
gesture.StartPosition.x, gesture.StartPosition.y, raycastFilter, out hit))
{
else
{
var gameObject = Instantiate(ObjectPrefab, hit.Pose.position,
hit.Pose.rotation);
count++;
CanvasController.ActivateCanvas();
var manipulator =
Instantiate(ManipulatorPrefab, hit.Pose.position,
hit.Pose.rotation);
gameObject.transform.parent = manipulator.transform;
manipulator.transform.parent = anchor.transform;
manipulator.GetComponent<Manipulator>().Select();
}
}
}
}
}
124