Hasta hace poco, la celebración de su mano a su templo para manipular un pequeño touchpad es cómo se tenía que utilizar auriculares engranaje VR. Bluetooth permite gamepads algunos juegos de engranajes de realidad virtual para apoyar las opciones más de entrada, pero la incorporación de movimiento natural en la experiencia VR faltaba.

En abril de 2017, Samsung lanzó el controlador Gear VR con incorporada sensores que la orientación pista. En aplicaciones que aprovechan los grados de libertad del controlador, el controlador se convierte en una parte de la experiencia de realidad virtual, como un puntero, una pistola, una varita mágica, un palo de golf, un palo de vuelo, o cualquier otro dispositivo que se basa en la rotación. Se puede ver la funcionalidad del controlador de engranajes VR en la aplicación Oculus Inicio. Cuando se combina el controlador, y se encuentra en el entorno de Oculus Inicio, verá una imagen del controlador que gira a medida que gira el mando en la mano.

Una vez que se empareje el controlador de engranaje VR, no es necesario modificar sus aplicaciones para poder utilizar la funcionalidad básica touchpad. Sin embargo, para aprovechar al máximo las funciones del controlador, tendrá que hacer algunos cambios a sus proyectos. Oculus proporciona las secuencias de comandos y las casas prefabricadas que se necesitan en los Oculus Utilidades para el paquete de la Unidad.

En este tutorial, vamos a utilizar el paquete Oculus Utilidades para crear un juego de disparos que demuestra la funcionalidad del controlador.
No se pierda! extremos de la oferta en

  • Accede a los más de 200 cursos
  • Nuevos cursos añadió mensual
  • Cancelar en cualquier momento
  • Los certificados de terminación

    ACCESO ahora

    Indice

    Fuente archivos de código

    Puede descargar el proyecto completo aquí. Este proyecto fue creado en la Unidad 5.6.1.

    Configuración del Proyecto

    Descargar Oculus útilies para la Unidad 5 de https://developer.oculus.com/downloads/package/oculus-utilities-for-unity-5/ y descomprimir el archivo zip en su ordenador.

    Crear un nuevo proyecto en la Unidad. Puse el nombre de mi ShooterWithController proyecto. Utilidades de importación Oculus por la selección de activos -> Importar paquete -> paquete personalizado y elegir el paquete que ha extraído. Si se le solicita que actualice el paquete, siga las instrucciones para instalar la actualización y reiniciar la unidad.


    Un directorio llamado OVR se añadirá a los activos de su proyecto.


    Para preparar el proyecto que se construirá, vaya a Archivo -> configuración de generación. Seleccionar Android como plataforma.


    Haga clic en Configuración del reproductor de PlayerSettings carga int Inspector panel.Set un nombre de la empresa y el nombre del proyecto. Bajo el título “Otros ajustes”, seleccionar “Realidad virtual admitida.” Añadir Oculus bajo el SDK de realidad virtual. Seleccione Android 4.4 Kit-Kat (API nivel 19) en el campo Mínimo nivel de API bajo el título “Identificación”. Esta es la versión mínima de Android que soporta el engranaje de realidad virtual.


    Cree el directorio Activo / plugins / Android / activos en su proyecto, y copiar archivos oculussig del teléfono para este directorio. Ver https://dashboard.oculus.com/tools/osig-generator/ si usted no tiene un archivo oculussig para su teléfono.

    Uso OVRCameraRig

    Vamos a echar un vistazo a la guía OVR que se importó en la carpeta Activos de su proyecto. En Activos / OVR / casas prefabricadas, OVRCameraRig es una casa prefabricada que sustituye a la cámara principal por defecto.


    Para usar OVRCameraRig, arrastre el OVRCameraRig prefabricada a la escena. Eliminar la MainCamera que se crea de forma predeterminada.

    Otra prefabricada, GearVRController, representa el controlador. Uno de sus componentes es un modelo del controlador en sí. Cuando está activo, el controlador será visible en la aplicación VR.

    Arrastre el prefabricada GearVRController tanto LeftHandAnchor y RightHandAnchor bajo OVRCameraRig.


    Seleccione la instancia de GearVRController bajo LeftHandAnchor. En el panel Inspector, configure el campo Controlador del guión OVR regulador del juego de “L orugas remoto”. Ajuste el campo Controlador de la GearVRController bajo RightHandAnchor a “R orugas remoto”.


    ¿Qué GearVRController está activo depende de la forma de configurar el controlador cuando la vinculación con su teléfono. Si configura el controlador al modo diestro, el controlador bajo RightHandAnchor estará activo. En su aplicación, que aparecerá en la parte derecha. Si es zurdo, su controlador, el controlador bajo LeftHandAnchor estará activo.

    Para ver el controlador en la acción, excepto la escena y seleccione Archivo -> Generar y ejecutar. Cuando la aplicación se está ejecutando, debe consultar a un controlador que gira a medida que gira el mando en la mano.


    Entender GearVrController

    En los juegos reales, es probable que la imagen del controlador para un aspecto diferente. Podemos personalizar la apariencia y el comportamiento del controlador mediante la construcción de nuestra propia casa prefabricada controlador basado en el GearVRController prefabricados proporciona en el paquete Oculus Utilidades. Vamos a echar un vistazo a la casa prefabricada GearVRController en el Activo / OVR / casas prefabricadas.

    El script Activos / OVR / Scripts / util / OVRGearVrController.cs se une a GearVRController. OVRGearVRController.cs abiertos:
    OVRGearVrController clase pública: MonoBehaviour {///

    /// El GameObject raíz que debe ser habilitado de forma condicional dependiendo del estado de conexión del controlador. /// m_model GameObject pública; ///

    /// El controlador que determina si se activa o no la representación del modelo de controlador. /// m_controller OVRInput.Controller pública; private bool m_prevControllerConnected = false; private bool m_prevControllerConnectedCached = false; vacío Update () {int controllerConnected = OVRInput.IsControllerConnected (m_controller); if ((controllerConnected = m_prevControllerConnected) || m_prevControllerConnectedCached!) {m_model.SetActive (controllerConnected); m_prevControllerConnected = controllerConnected; m_prevControllerConnectedCached = true; } If (controllerConnected!) {Return; }}} 1234567891011121314151617181920212223242526272829303132publicclassOVRGearVrController: MonoBehaviour {///

    /// El GameObject raíz que se debe activar de forma condicional dependiendo de la conexión de controladores status./// publicGameObject m_model; ///

    /// El controlador que determina si se activa o no la representación del controlador model./// publicOVRInput.Controller m_controller; privateboolm_prevControllerConnected = false; privateboolm_prevControllerConnectedCached = false; voidUpdate () {boolcontrollerConnected = OVRInput.IsControllerConnected (m_controller); if (( controllerConnected = m_prevControllerConnected) || m_prevControllerConnectedCached)! {m_model.SetActive (controllerConnected); m_prevControllerConnected = controllerConnected; m_prevControllerConnectedCached = true;} if (controllerConnected) {return;}}}

    m_model es la manifestación física del controlador. En el inspector, su valor se establece en el modelo de objetos que está anidado bajo GearVrController. m_controller es una instancia de un tipo enumerado, OVRInput.Controller, que se define en OVRInput.cs. Los enumeradores de OVRInput.Controller son todos los tipos de controladores válidos. Para el controlador de engranajes VR, sólo nos referimos a la izquierda o derecha seguimiento remoto seguimiento remoto. Al configurar las instancias de GearVrController, es necesario rellenar el campo m_controller con “R orugas remoto” o “L orugas remoto” en el inspector. El m_prevControllerConnected boolean mantiene un seguimiento de si este controlador estaba activo.

    Update () comprueba si m_controller está conectado llamando OVRInput.IsControllerConnected () .Si el booleano resultante ha cambiado desde la última actualización, m_model se activa o desactiva en función de si m_controller está conectado. Por ejemplo, si el controlador engranaje VR es diestro, cuando se inicia la aplicación, la instancia del conjunto OVRGearVrController a “R orugas remoto” detectará que su m_controller está conectado. La imagen del mando a distancia para diestros se hará visible en la aplicación. El conjunto instancia a “L orugas remoto” detectará que su m_controller no está conectado, y no se activará su m_model. El mando a distancia con la mano izquierda no será visible.

    Creación de una pistola

    Ahora que hemos explorado el prefabricada GearVrController por defecto, vamos a crear nuestra propia casa prefabricada que convertirá el controlador engranaje VR en una pistola. Pero primero, vamos a crear un suelo donde los proyectiles de la pistola pueden caer.

    Crea un avión y cambiarle el nombre “tierra”. Arrastre el OVRCameraRig a lo largo del eje Y de modo que está por encima del suelo. Crear un nuevo material en el activo / Materiales nombre “GroundMaterial.” Establecer su albedo a un color marrón.



    Para preparar el arma, crear un nuevo material para que, Activos / Materiales / GunMaterial. Ajuste el color de albedo en el inspector y ajustar el deslizador metálico para hacer la mirada más realista de material.


    Crear un cubo en la escena denominada GunModel. Arrastre GunMaterial a este cubo de aplicarlo. Redimensionar GunModel a una forma larga y delgada que es lo suficientemente pequeño como para que parezca un controlador de mano. Cuando la transformada control está seleccionado, asegúrese de que las líneas de eje azul más oscuro con el lado largo. Los azules se alinea con el eje de la cara delantera del cubo.


    A continuación, crear un objeto vacío en la escena y el nombre que VrGunController. VrGunController será nuestro reemplazo para GearVrController. GunModel Nest bajo VrGunController de arrastrar y soltar.


    A continuación, vamos a crear una bala que puede ser disparado por el arma. Crear una esfera y cambiar su tamaño hasta que se vea lo suficientemente pequeño para ser disparada por el arma razonablemente. Cambiarle el nombre bala. Crear un nuevo material para que en el activo / Materiales y aplicar el material arrastrándolo a bala.

    Añadir un cuerpo rígido de la bala, lo que nos permitirá establecer una velocidad y aplicar la cinemática a ella. Tenga en cuenta que la bala ya tiene un colisionador esfera alrededor de ella. Marque la casilla junto a “es Trigger.” Vamos a utilizar este campo para poner en práctica más adelante disparando a los enemigos.


    Arrastre bala a activos / casas prefabricadas, y retirar la bala original, que ha creado en la escena. El prefabricada bala se utiliza para inicializar las balas al disparar el arma.

    Ahora vamos a añadir secuencias de comandos para VrGunController y GunModel. Añadir los scripts activos / OVR / Scripts / Útil / OVRGearVrController a VrGunController. Esto permite VrGunController para ser utilizado como el controlador Gear VR. Arrastre GunModel al campo modelo. Por ahora, no rellenar el campo Controlador. Vamos a establecer el uso de las manos del controlador cuando asignamos una instancia de VrGunController a una de las anclas en OvrCameraRig.


    Crea un nuevo C # script, GunController, en el Activo / Secuencias de comandos:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; GunController clase pública: {MonoBehaviour pública GameObject projectilePrefab; // Usar esto para la inicialización de inicio void () {this.transform.forward = Camera.main.transform.forward; } Public void ShootProjectile (float projectileSpeed) {GameObject proyectil = GameObject.Instantiate (projectilePrefab); projectile.transform.position = this.transform.position; Cuerpo rígido rb = projectile.GetComponent (); rb.velocity = this.transform.forward * projectileSpeed; }} 123456789101112131415161718192021222324usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassGunController: MonoBehaviour {publicGameObject projectilePrefab; // Usar esto para initializationvoidStart () {this.transform.forward = Camera.main.transform.forward;} publicvoidShootProjectile (floatprojectileSpeed) { GameObject proyectil = GameObject.Instantiate (projectilePrefab); projectile.transform.position = this.transform.position; cuerpo rígido rb = projectile.GetComponent (); rb.velocity = this.transform.forward * projectileSpeed;}}

    Inicio (), llama cuando se inicializa el GunController, señala el GunModel en la misma dirección que la cámara. orientaciones posteriores son fijados por el jugador que mueve el controlador.

    ShootProjectile (projectileSpeed) se llama cuando se tira del gatillo del controlador Gear VR. ShootProjectile () crea la instancia de una instancia de la prefabricada proyectil y los incendios en la misma dirección que la pistola está apuntando con una velocidad determinada por projectileSpeed.

    Arrastre GunController al objeto GunModel para agregarlo como un componente. En el inspector, juego “Proyectil prefabricada” a bala.


    Vamos a añadir el código para detectar que el gatillo de activos / OVR / Scripts / Útil / OVRGearVrController, que adjuntamos a VrGunController. Abra el guión y añadir las siguientes líneas al final del método update ():
    si (OVRInput.GetUp (OVRInput.Button.PrimaryIndexTrigger)) {if (m_gunController! = null) {debug.log ( «OVRGearVrController: proyectil de disparo»); m_gunController.ShootProjectile (projectileSpeed); } Else {debug.log ( «OVRGearVrController: m_gunController es nulo»); }} 12345678if (OVRInput.GetUp (OVRInput.Button.PrimaryIndexTrigger)) {if (m_gunController! = Null) {debug.log ( «OVRGearVrController: Disparo de proyectil»); m_gunController.ShootProjectile (projectileSpeed);} else {debug.log ( «OVRGearVrController: m_gunController es nulo»);}}

    añadir también los siguientes miembros de datos de la clase OVRGearVrController:
    público GunController m_gunController; flotador público projectileSpeed ​​= 20f; 12publicGunController m_gunController; publicfloatprojectileSpeed ​​= 20f;

    En el panel inspector, establece el campo “Gun Controller” a GunModel. GunController componente de GunModel será el valor de m_gunController. Cuando se pulsa el botón de disparo del controlador Gear VR y se suelta, si m_gunController está activo, ShootProjectile () se llama con una velocidad de projectileSpeed, que también se puede ajustar en el inspector. De ensayo y error, 20 es una velocidad razonable.


    Arrastre VrGunController a Activos / casas prefabricadas, y quitar VrGunController de la escena por ahora. Vamos a añadir la parte posterior prefabricada a la escena en el siguiente paso.

    Usted todavía debe tener una instancia de OVRCameraRig en su escena. Retire GearVrController de OVRCameraRig -> TrackingSpace -> LeftHandAnchor y OVRCameraRig -> TrackingSpace -> RightHandAnchor. Entonces arrastrar y soltar VrGunController de activos / Prefabs dos veces, una vez para nido bajo LeftHandAnchor, y una vez para anidar bajo RightHandAnchor.


    Seleccione el VrGunController bajo LeftHandAnchor. En el inspector, ajuste del controlador bajo “OVR Controller Vr Gear (Script)” a “L orugas remoto”.


    Del mismo modo, establecer la instancia VrGunController bajo RightHandAnchor a “R orugas remoto”.

    Cuando se construye y ejecuta el proyecto en su teléfono con el controlador asociado, debería ver una imagen de la GunModel que puede girar mediante la rotación de su controlador. Al hacer clic en el botón de disparo, las balas se dispararon desde la pistola.

    Agregando Enemies

    Ahora vamos a añadir enemigos podemos apuntar con la pistola controlador habilitado. El proyecto incluye adjunta un modelo de Blender, Activos / Modelos / GhostModel.fbx, que puede ser utilizado como modelo prefabricado para nuestros enemigos. Copiar este archivo a en activos de su proyecto / Modelos carpeta.

    Crear un nuevo GameObject, Fantasma. En el menú desplegable Tag en el inspector, seleccionar “Añadir etiqueta” y aplicarlo a Santo.


    Arrastre GhostModel al objeto fantasma para anidar a él.


    En la vista de escena, utilice el widget de rotación para rotar GhostModel hasta que esté vertical, y escalar a un tamaño que parece razonable, en la escena. Añadir un colisionador cápsula para Santo. Haga clic en “Editar Colisionador” y cambiar el tamaño de la cápsula verde hasta que aproximadamente encierra el fantasma.


    Crear un nuevo C # script, Activos / Scripts / EnemyController, y adjuntarlo al Santo. EnemyController controlará el movimiento del fantasma:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; public class EnemyController: {MonoBehaviour velocidad de flotación = 2f; // actualización se llama una vez por trama de actualización void () {transform.Translate (-1 * Vector3.forward * velocidad * Time.deltaTime, Space.World); } Public void SetSpeed ​​(flotar Newspeed) {= velocidad Newspeed; }} 123456789101112131415161718usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassEnemyController: MonoBehaviour {floatspeed = 2f; // actualización se llama una vez por framevoidUpdate () {transform.Translate (-1 * Vector3.forward * velocidad * Time.deltaTime, Space.World);} publicvoidSetSpeed ​​(floatnewSpeed) {velocidad = Newspeed;}}

    las método update () mueve el fantasma hacia adelante cada actualización marco .

    Ahora arrastre Santo desde el panel de jerarquías en activos / casas prefabricadas, y quitar el fantasma que ha creado en la escena. Los fantasmas se crearán mediante programación en el inicio del juego por un objeto GameManager.

    Crear un nuevo GameObject vacío llamado GameManager. Adjuntar un nuevo C # script para que, Activos / Scripts / GameManager:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; GameManager clase pública: {MonoBehaviour pública GameObject enemyPrefab; numEnemies public int = 10; enemySpeed ​​flotación pública; // Usar esto para la inicialización de inicio void () {SpawnEnemies (); } // actualización se llama una vez por cuadro de actualización de vacío () {} SpawnEnemies void () {float = startX -20F; flotar xCoord = startX; flotar zCoord = 15; altura del flotador = 1.5f; int enemiesInRow = 5; for (int i = 0; i () SetSpeed ​​(enemySpeed).; xCoord + = 10f; // Incremento de la coordenada z si una fila está llena. if ((i + 1)% enemiesInRow == 0) {xCoord = startX; zCoord + = 2f; } //NewEnemy.transform.forward = -1 * Camera.main.transform.forward; }}} 1234567891011121314151617181920212223242526272829303132333435363738394041usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassGameManager: MonoBehaviour {publicGameObject enemyPrefab; publicintnumEnemies = 10; publicfloatenemySpeed; // Use esto para initializationvoidStart () {SpawnEnemies ();} // actualización se llama una vez por framevoidUpdate () {} voidSpawnEnemies () {floatstartX = -20F; floatxCoord = startX; floatzCoord = 15; floatheight = 1.5f; intenemiesInRow = 5; para (INTI = 0; i () SetSpeed ​​(enemySpeed);. xCoord + = 10f ; // Incremento la coordenada z si una fila es filled.if ((i + 1)% enemiesInRow == 0) {xCoord = startX; zCoord + = 2f;} // newEnemy.transform.forward = -1 * Camera.main .transform.forward;}}}

    el miembro de datos enemyPrefab es la plantilla utilizada para crear enemigos. En el inspector, poblar “Enemigo prefabricada” con Ghost. El número de enemigos para desovar y la velocidad de los enemigos también se pueden configurar en el inspector.

    SpawnEnemies (), llamado cuando GameManager inicializa, crea numEnemies enemigos en filas igualmente espaciadas.

    Todavía tenemos que ser capaces de detectar cuando un enemigo es golpeado por una bala. Crear un nuevo C # script, Activos / Scripts / BulletController, y agregarlo a la bala prefabricada que creamos anteriormente:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; BulletController clase pública: MonoBehaviour {float maxDistance pública = 100F; // Usar este vacío para la inicialización de inicio () {} // actualización se llama una vez por cuadro de actualización void) {// Autodestrucción (si supera esta bala maxDistance de la cámara. si (Vector3.Distance (transform.position, Camera.main.transform.position)> maxDistance) {Destruir (GameObject); }} // detectar colisiones. OnTriggerEnter vacío (Colisionador de otra) {debug.log ( «BulletController :: OnTriggerEnter»); // Si la bala ha colisionado con un enemigo, destruir al enemigo y él mismo. si (other.gameObject.CompareTag ( «Enemigo»)) {debug.log ( «BulletController :: OnTriggerEnter: chocó con enemigo»); Destruye (other.gameObject); Destruye (GameObject); }}} 12345678910111213141516171819202122232425262728293031323334usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassBulletController: MonoBehaviour {publicfloatmaxDistance = 100F; // Usar esto para initializationvoidStart () {} // actualización se llama una vez por framevoidUpdate () {// si Autodestrucción esta bala excede maxDistance de la camera.if (Vector3.Distance (transform.position, Camera.main.transform.position)> maxDistance) {Destruye (GameObject);}} // Detectar collisions.voidOnTriggerEnter (Colisionador otra) {depuración. log ( «BulletController :: OnTriggerEnter»); // Si la bala ha colisionado con un enemigo, destruir al enemigo y itself.if (other.gameObject.CompareTag ( «enemigo»)) {debug.log ( «BulletController :: OnTriggerEnter: chocó con enemigo «); Destruye (other.gameObject); Destruye (GameObject);}}}

    Anteriormente, hemos hecho esfera de bala colisionador un disparador. OnTriggerEnter () se llama cuando otro colisionador entra en el gatillo – en otras palabras, cuando una bala choca con otro objeto con un colisionador. Si el otro objeto está etiquetado “Enemigo”, destruimos el objeto y la bala.

    Actualizar () comprueba hasta qué punto la bala es de la cámara principal. La bala se destruye si esta distancia supera maxDistance. Esto evita llenar la escena con balas perdidas. Tenga en cuenta que no es necesario para mover de forma explícita la bala porque ya hemos asignado una velocidad de cuerpo rígido de la bala en GunController :: ShootProjectile ().

    En este punto, tenemos un juego que utiliza el controlador de engranajes RV como un arma para disparar fantasmas flotantes. Hay mucho margen de mejora, pero tiene lo básico de cómo utilizar la unidad Utilidades para apoyar el controlador engranaje VR.


    Mensajes relacionados
     ¿Cómo crear un shooter en primera persona en el Unreal Engine

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *