En mi anterior tutorial sobre el controlador engranaje VR, hemos aprendido cómo utilizar el paquete de Oculus Utilidades para utilizar el controlador Gear RV como un arma de fuego o dispositivo de puntero. Ahora vamos a utilizar el controlador como un joystick para controlar una nave espacial. En vez de reutilizar y modificar las casas prefabricadas Oculus Utilidades, vamos a ser directamente el acceso a la orientación del controlador para manipular una nave espacial volando sobre un planeta extraño.

Tabla de contenidos

Descargas

Puede descargar el proyecto Unity para este tutorial aquí. El directorio OVR creado por Oculus Utilidades está incluido. El modelo de nave espacial incluidos en los activos del proyecto fue creado por Liz Reddington. Está autorizado debajo CC-BY 3.0 y está disponible en la nave espacial – Poli en Google
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

    Configuración del Proyecto

    Para comenzar, cree un nuevo proyecto en la Unidad. Crear los elementos de la carpeta / plugins / Android / activo, y copiar archivo de firma Oculus del teléfono allí. Ver Oculus archivo de firma (OSIG) y firma de aplicaciones para crear un nuevo archivo de firma.

    Descargar Oculus útilies para la Unidad 5 de la Oculus Utilidades para la Unidad del sitio y descomprimir el archivo zip en su ordenador. Utilidades de importación Oculus en su proyecto mediante 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 extrae en 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. Establecer un nombre de empresa y nombre del proyecto. Bajo el título “Otros ajustes”, seleccionar “Virtual Reality compatible” y añadir a Oculus “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.


    OVRInput

    En mi tutorial anterior, se utilizó el OVRCameraRig prefabricada del paquete Oculus Utilidades (OVR). Las secuencias de comandos que detectan los controladores ya estaban asociadas a las casas prefabricadas. Ahora que no estamos usando las casas prefabricadas, tenemos que unir las secuencias de comandos adecuados y escribir código adicional para la rotación controlador de mango.

    En primer lugar, vamos a echar un vistazo al código proporcionado por Oculus Utilidades.

    Activo Abrir el script / OVR / scripts / OVRInput.cs. En la ventana de proyecto de la Unidad, nota que las secuencias de comandos de C # se muestran sin la extensión .cs, OVRInput.cs se parece a OVRInput. Al crear sus propios scripts, y el icono de la secuencia de comandos aparece en la ventana del proyecto, no añada la extensión .cs manualmente. Si lo hace, el verdadero nombre de la secuencia de comandos se verá como MyScript.cs.cs, y la unidad no será capaz de encontrarlo.


    La documentación en el guión OVRInput lo describe como un sistema de entrada unificado para los controladores y gamepads Oculus. La sección que nos ocupa la mayor parte es el controlador enumeran tipo que se asigna a OVRPlugin.Controller:
    enum público Controller {Ninguno = OVRPlugin.Controller.None, /// activos / OVR / scripts / OVRPlugin.cs, OVRPlugin .Controller es un ofvalues ​​de enumeración que representan cada tipo de controlador.
    public enum {Controlador Ninguno = 0, LTouch = 0x00000001, 0x00000002 = RTouch, tacto = LTouch | RTouch, distancia = 0x00000004, Gamepad = 0x00000010, Unidad de entrada = 0x08000000, LTrackedRemote = 0x01000000, RTrackedRemote = 0x02000000, activo = sin marcar ((int) 0x80000000), Todos = ~ Ninguna,} 1234567891011121314publicenumController {Ninguno = 0, LTouch = 0x00000001, RTouch = 0x00000002, tacto = LTouch | RTouch, distancia = 0x00000004, Gamepad = 0x00000010, Unidad de entrada = 0x08000000, LTrackedRemote = 0x01000000, RTrackedRemote = 0x02000000, activo = sin marcar ((int) 0x80000000), Todos = ~ Ninguna,}

    El engranaje VR controlador puede ser o bien LTrackedRemote o RTrackedRemote, dependiendo de si se está configurado zurdo o diestro. Actualmente, no se admite la conexión de dos controladores engranaje VR, pero esto podría cambiar en el futuro.

    En representación de tipos de controladores con los números nos permite usar operaciones binarias para almacenar y extraer múltiples tipos de controlador en una variable. Cuando se calcula el operador OR de dos números binarios, que preservar todos los bits en ambas máscaras. Por ejemplo, el operador OR de 0001 y 0010 es 0011. Tanto 1 de se conservan en el resultado. Cuando se calcula el AND bit a bit de 0001 y 0011, volvamos 0001.


    Esta técnica nos permite combinar tipos de controlador calculando el operador OR de dos o más OVRPlugin.Controller valores. Por lo tanto, podemos combinar LTrackedRemote y RTrackedRemote calculando su OR bit a bit. OVRPlugin.GetConnectedControllers () devuelve un operador OR de todos los controladores conectados. Podemos determinar si LTrackedRemote o RTrackedRemote es uno de ellos mediante el uso de operaciones bit a bit:
    gearController = connectedControllers y (OVRInput.Controller.LTrackedRemote | OVRInput.Controller.RTrackedRemote); 1gearController = connectedControllers y (OVRInput.Controller.LTrackedRemote | OVRInput.Controller.RTrackedRemote);

    Si, por ejemplo, LTrackedRemote está conectado, el resultado de la bit a bit y será LTrackedRemote, y este valor se almacena en la variable gearController. Lo mismo se aplica para RTrackedRemote. Si ninguno está conectado, el valor gearController ‘s será OVRInput.Controller.None.

    Una vez que se identifica el controlador engranaje VR activo, podemos obtener su cuaternión de rotación llamando OVRInput.GetLocalRotation (). Entonces podemos utilizar esta rotación para manipular nuestra nave espacial.

    ShipController

    Nuestro código para mover la nave espacial pasará en los ShipController.cs script. Cree la carpeta Activos / Scripts en su proyecto, y en esta carpeta crear el guión ShipController.

    inicio al declarar miembros de datos ShipController ‘s:
    ShipController clase pública: MonoBehaviour {[SerializeField] Velocidad de flotación = 0.0f; [SerializeField] Transformar vrCameraContainer; gearController OVRInput.Controller privado; Transformar privada objetivo; // marcador diana donde la nave espacial se moverá en cada trama. distanceToCamera flotador privado; // …} 12345678910publicclassShipController: MonoBehaviour {[SerializeField] floatspeed = 0.0f; [SerializeField] Transform vrCameraContainer; privateOVRInput.Controller gearController; objetivo privateTransform; // marcador diana donde la nave espacial se moverá en cada trama. privatefloatdistanceToCamera; // …}

    Los valores de los campos que están marcados como [SerializeField] se pueden establecer en el inspector, a pesar de que su alcance es privada. La velocidad variable es la velocidad a la que se moverán el contenedor de cámara y el buque. vrCameraContainer es la transformada de juego el objeto que va a contener la cámara principal.

    La variable gearController almacenará el valor de lo que el controlador está activo. El objetivo representa la posición de destino de la nave espacial en cada marco. Por último, distanceToCamera almacena la distancia entre la nave espacial y vrCameraContainer.

    Cuando se inicia el juego, se calcula distanceToCamera en el método Awake (), que se llama automáticamente antes de que comience el partido, pero después de todos los objetos se inicializan. También vamos a initialize objetivo inicial a la transformada de la nave espacial.
    void Awake () {target = transformar; distanceToCamera = Vector3.Distance (vrCameraContainer.position, transform.position);} 12345voidAwake () {target = transformar; distanceToCamera = Vector3.Distance (vrCameraContainer.position, transform.position);}

    Necesitamos código para determinar qué controladores están conectados, por tanto, crear un método, SetController ():
    SetController private void () {OVRInput.Controller connectedControllers = OVRInput.GetConnectedControllers (); Debug.log (connectedControllers); gearController = connectedControllers y (OVRInput.Controller.LTrackedRemote | OVRInput.Controller.RTrackedRemote);} 123456privatevoidSetController () {OVRInput.Controller connectedControllers = OVRInput.GetConnectedControllers (); debug.log (connectedControllers); gearController = connectedControllers y (OVRInput.Controller.LTrackedRemote | OVRInput.Controller.RTrackedRemote);}

    OVRInput.GetConnectedControllers () devuelve todos los controladores conectados. El gearController se establece en LTrackedRemote o RTrackedRemote o ninguno, utilizando la técnica de manipulación de bits que discutimos en la sección anterior.

    También se necesita un método que devuelve la rotación del controlador conectado:
    Quaternion GetOrientation privada () {OVRInput.GetLocalControllerRotation retorno (gearController);} 1234privateQuaternion GetOrientation () {returnOVRInput.GetLocalControllerRotation (gearController);}

    Crear un método, MoveShip (), que será llamada para actualizar la posición de la nave espacial cada cuadro .
    void MoveShip () {Quaternion controllerRotation; Vector3 origPosition = transform.position; SetController (); controllerRotation = GetOrientation (); // Mover la cámara. vrCameraContainer.Translate (Vector3.forward * velocidad * Time.deltaTime); // Calcular la posición de destino de la nave. target.position = vrCameraContainer.position + (controllerRotation * Vector3.forward) * distanceToCamera; // Interpolar la rotación de la nave para que coincida con la rotación de la controladora. transform.rotation = Quaternion.Slerp (transform.rotation, controllerRotation, velocidad * Time.deltaTime); // nave avanzar hacia un objetivo transformar. transform.position = Vector3.Lerp (transform.position, target.position, velocidad * Time.deltaTime); } 1234567891011121314151617181920voidMoveShip () {Quaternion controllerRotation; Vector3 origPosition = transform.position; SetController (); controllerRotation = GetOrientation (); // Mueva el camera.vrCameraContainer.Translate (Vector3.forward * velocidad * Time.deltaTime); // Calcular la position.target.position objetivo de la nave = vrCameraContainer.position + (controllerRotation * Vector3.forward) * distanceToCamera; // Interpolar la rotación de la nave para que coincida con rotation.transform.rotation del controlador = Quaternion.Slerp (transform.rotation, controllerRotation, velocidad * Tiempo .deltaTime), o buque // Mover a la transform.transform.position target = Vector3.Lerp (transform.position, target.position, velocidad * Time.deltaTime);}

    Vea Vamos a cómo funciona este. En primer lugar, SetController () establece el valor de gearController. Tenemos que hacer esto cada cuadro ya que el controlador se puede desconectar o volver a conectar en cualquier momento. El método GetOrientation () adquiere cuaternión de rotación del controlador.

    Nuestra vrCameraContainer se mueve hacia adelante por una distancia determinada por la velocidad. La nave espacial también se moverá hacia adelante por la misma velocidad, pero la dirección de su movimiento es determinado por el controlador. Cada trama, la nave espacial se moverá a la posición del objetivo transformar, que se calcula multiplicando la rotación de la controlador por el vector hacia adelante para determinar una nueva dirección. Este producto se multiplica por distanceToCamera para mantener la distancia entre la nave espacial y la cámara. El Vector3.Lerp () linealmente interpola la posición de la nave espacial a la posición del objetivo para una transición suave.

    Cada trama, MoveShip () es llamado por un Update () método que runsautomatically.
    vacío Update () {MoveShip ();} 1234voidUpdate () {MoveShip ();}

    Configuración del Activos del Juego

    Ahora que nuestro código está escrito, necesitamos juntar los activos del juego. Vamos a necesitar un modelo de nave espacial, así como objetos del terreno o vuelan a hacer el juego más interesante y para demostrar que la nave espacial se mueve realmente.

    Por ahora, estoy usando uno de los modelos de terreno desde el tutorial VirtualTour. Este archivo, Mountains.fbx, también está disponible en el archivo de proyecto incluido. Crear una carpeta, Activos / Modelos, en su proyecto, y copiar Mountains.fbx allí.

    El modelo de nave espacial es un activo de bajo poli descargado de Google Poly. Sus archivos, y Lo_poly_Spaceship_03_by_Liz_Reddington.mtl Lo_poly_Spaceship_03_by_Liz_Reddington.obj, también se incluyen en el proyecto adjunto. Agregar estos archivos a Activos / Modelos.

    La cámara se encuentra a una distancia fija detrás de la nave espacial para proporcionar una vista en tercera persona. En VR, nunca se mueven directamente la cámara porque la cámara es controlada por la cabeza del jugador. En su lugar, vamos a anidar el objeto de cámara dentro de otro contenedor.

    Crea un objeto vacío con el nombre del juego VRCameraContainer . Arrastre Cámara principal en VRCameraContainer a anidar a él.


    Uso del widget y transformar las flechas para mover VRCameraContainer a una altura adecuada por encima del terreno.


    También necesita crear un contenedor para el modelo de nave espacial. Crear un objeto vacío, PlayerShip . Arrastre el modelo de nave espacial en el panel de jerarquías, que anidan en los términos de PlayerShip .


    Reducir tamaño de la nave espacial por lo que parece razonable, y ajustar su coordenada z para colocarlo delante de la cámara.


    Adjuntar el guión ShipController al objeto PlayerShip.


    Arrastre el objeto VRCameraContainer al campo “Vr cámara de contenedores” en el inspector, y establecer una velocidad.

    Encontrar el controlador

    Si se ejecuta el juego en este momento, se puede encontrar que el barco no se mueve junto con el controlador. ¿Qué está pasando?

    Vamos a echar un vistazo a cómo el juego se sabe que un controlador está conectado.

    OVR / Scripts / OVRInput.cs determina whichcontrollers están conectados en el Update () y FixedUpdate () métodos. Sin embargo, OVRInput es una clase estática que no está conectado a cualquier objeto del juego, por lo que los métodos de actualización OVRInput ‘s nunca se les llama. No importa lo que haces, el juego no va a ver a su controlador.

    Para resolver esta situación, tendremos que crear un script que llama OVRInput.Update () y OVRInput.FixedUpdate (), y adjuntar este script a un objeto. Crear un objeto de juego vacío llamado VRManager . Crear un nuevo C # script, Activos / Scripts / VRInputManager, con el siguiente código:
    utilizando System.Collections; usando System.Collections.Generic; usando UnityEngine; public class VRInputManager: MonoBehaviour {// actualización se llama una vez por cuadro de actualización de vacío () {if (OVRManager.instance == null) {OVRInput.Update (); }} FixedUpdate void () {if (OVRManager.instance == null) {OVRInput.FixedUpdate (); }}} 12345678910111213141516171819usingSystem.Collections; usingSystem.Collections.Generic; usingUnityEngine; publicclassVRInputManager: MonoBehaviour {// actualización se llama una vez por framevoidUpdate () {if (OVRManager.instance == null) {OVRInput.Update ();}} voidFixedUpdate ( ) {if (OVRManager.instance == null) {OVRInput.FixedUpdate ();}}}

    VRInputManager.Update () llama OVRInput.Update (), pero sólo si OVRManager no existe. OVRManager Es otro objeto incluido en Oculus Las utilidades que llama OVRInput. Dado que no necesitamos la mayor parte de su funcionalidad, no estamos utilizando la misma.

    Adjuntar el guión VRInputManager al objeto VRManager.


    Para probar el proyecto, guardar la escena. He creado una carpeta llamada Activos / escenas y se guarda la escena como principal. En la ventana de configuración de creación, hacer que el nombre de la escena se comprueba en las escenas en la estructura del rectángulo. Con el teléfono conectado, haga clic en el botón Ejecutar y Construir, y elegir un nombre para el APK.I creó una carpeta de compilación y se guarda el archivo APK allí.


    Cuando se carga la aplicación, conectar el teléfono en el auricular para ejecutarlo. Si el controlador está emparejado con el teléfono, pulse y mantenga pulsado el botón de inicio para activarlo.

    Rotación

    Al ejecutar la aplicación, se dará cuenta de que la posición de la nave espacial cambia con el controlador, pero su nariz apunta siempre hacia adelante, y siempre es nivel.

    Para hacer el movimiento de la nave espacial más realista, tenemos que cambiar su rotación como el controlador de movimientos.

    Me trató diversos cálculos angulares, pero resultó que el más realista -looking ángulos ocurrió cuando simplemente he utilizado la rotación del controlador como el de rotación objetivo de la nave espacial.

    En los ShipController.cs de secuencia de comandos, se obtiene un cuaternión de OVRInput.GetLocalRotationController () que representa la rotación del controlador. Quaternions se componen de cuatro números que en conjunto representan una rotación en una esfera. Conceptualmente, los cuaterniones son complejos – de hecho, son una extensión de los números complejos – pero la Unidad proporciona abstracciones que permiten rotar un objeto con cuaterniones en unas pocas líneas de código .

    Unidad proporciona una función, Quaternion.Slerp (), que realiza una interpolación lineal esférica, o slerp, para girar un objeto sin problemas de un cuaternión a otro. Slerp es una interpolación a lo largo de un arco esférico. El otro tipo de interpolación, interpolación lineal, o lerp, interpola a lo largo de una línea recta. Lerp puede correr más rápido, pero slerp proporciona rotaciones suaves.

    Para añadir rotación, añadir la siguiente línea al ShipController.MoveShip () antes de la Vector3.Lerp () llamada:
    transform.rotation = Quaternion.Slerp (transform.rotation, controllerRotation, velocidad * Time.deltaTime); 1transform.rotation = Quaternion.Slerp (transform.rotation, controllerRotation, velocidad * Time.deltaTime);

    Este código interpola los de la nave orientación original a la orientación del controlador.

    Ahora intente ejecutar el juego. Se dará cuenta de que a medida que se mueve el controlador, los rollos nave espacial, lanzamientos, y los bancos, ya que cambia de dirección.



    Conclusión

    Ahora que tiene un punto de partida para utilizar el controlador engranaje VR como una palanca de vuelo, puede utilizar estas técnicas para construir sus propias simulaciones de vuelo y juegos de combate. Con el controlador, puede controlar un vehículo de forma más intuitiva, mientras se mueve la cabeza para mirar a su alrededor. Utilizando el controlador como un dispositivo de dirección proporciona un nuevo nivel de libertad y realismo a los juegos de engranaje de VR.

    Mensajes relacionados
    > <img src =

Deja una respuesta

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