HP Reverb G2-styrenheter i Unity

HP Motion-styrenheter är en helt ny typ av Windows Mixed Reality styrenheter: samma spårningsteknik med en något annorlunda uppsättning tillgängliga indata:

  • Pekplattan har ersatts av två knappar: A och B för den högra styrenheten och X och Y för den vänstra styrenheten.
  • Grasp är nu en utlösare som publicerar en dataström med värden mellan 0.0 och 1.0 i stället för en knapp med trycklägen och Inte tryckna tillstånd.

Eftersom de nya indata inte är tillgängliga via befintliga Windows- och Unity-API:er behöver du det dedikerade UPM-paketet Microsoft.MixedReality.Input.

Viktigt

Klasser i det här paketet ersätter inte befintliga Windows- och Unity-API:er utan kompletterar dem. Funktioner som ofta är tillgängliga för både klassiska Windows Mixed Reality-styrenheter och HP Motion Controllers är tillgängliga via samma kodsökväg med befintliga API:er. Endast de nya indata kräver att ytterligare Microsoft.MixedReality.Input-paket används.

Översikt över HP Motion Controller

Microsoft.MixedReality.Input.MotionController representerar en rörelsestyrenhet. Varje MotionController-instans har en XR. WSA. Input.InteractionSource-peer , som kan korreleras med hjälp av handlighet, leverantörs-ID, produkt-ID och version.

Du kan hämta MotionController-instanser genom att skapa en MotionControllerWatcher och prenumerera på dess händelser, ungefär som när du använder InteractionManager-händelser för att identifiera nya InteractionSource-instanser . MotionControllers metoder och egenskaper beskriver indata som stöds av styrenheten, inklusive knappar, utlösare, 2D-axel och tumsticka. Klassen MotionController visar även metoder för åtkomst till indatatillstånd via klassen MotionControllerReading . Klassen MotionControllerReading representerar en ögonblicksbild av kontrollantens tillstånd vid en viss tidpunkt.

Installera Microsoft.MixedReality.Input med funktionsverktyget för Mixed Reality

Installera plugin-programmet Microsoft.MixedReality.Input med det nya Mixed Reality-funktionsverktyget. Följ installations- och användningsanvisningarna och välj paketet Mixed Reality Input i kategorin Mixed Reality Toolkit:

Mixed Reality Feature Tool packages window with mixed reality input highlighted

Använda Microsoft.MixedReality.Input

Indatavärden

En MotionController kan exponera två typer av indata:

  • Knappar och utlösartillstånd uttrycks med ett unikt flyttalvärde mellan 0,0 och 1,0 som anger hur mycket de trycks ner.
    • En knapp kan bara returnera 0,0 (när den inte trycks in) eller 1,0 (när den trycks in) medan en utlösare kan returnera kontinuerliga värden mellan 0,0 (helt frisläppt) till 1,0 (helt tryckt).
  • Tumstickstillstånd uttrycks av en Vector2 vars X- och Y-komponenter är mellan -1.0 och 1.0.

Du kan använda MotionController.GetPressableInputs() för att returnera en lista över indata som returnerar ett nedtryckt värde (knappar och utlösare) eller metoden MotionController.GetXYInputs() för att returnera en lista över indata som returnerar ett 2-axelsvärde.

En MotionControllerReading-instans representerar kontrollantens tillstånd vid en viss tidpunkt:

  • GetPressedValue() hämtar tillståndet för en knapp eller en utlösare.
  • GetXYValue() hämtar tillståndet för en tumsticka.

Skapa en cache för att underhålla en samling MotionController-instanser och deras tillstånd

Börja med att instansiera en MotionControllerWatcher och registrera hanterare för dess MotionControllerAdded - och MotionControllerRemoved-händelser för att behålla en cache med tillgängliga MotionController-instanser. Den här cachen ska vara en MonoBehavior som är kopplad till en GameObject, vilket visas i följande kod:

public class MotionControllerStateCache : MonoBehaviour 
{ 
    /// <summary> 
    /// Internal helper class which associates a Motion Controller 
    /// and its known state 
    /// </summary> 
    private class MotionControllerState 
    { 
        /// <summary> 
        /// Construction 
        /// </summary> 
        /// <param name="mc">motion controller</param>` 
        public MotionControllerState(MotionController mc) 
        { 
            this.MotionController = mc; 
        } 

        /// <summary> 
        /// Motion Controller that the state represents 
        /// </summary> 
        public MotionController MotionController { get; private set; } 
        … 
    } 

    private MotionControllerWatcher _watcher; 
    private Dictionary<Handedness, MotionControllerState> 
        _controllers = new Dictionary<Handedness, MotionControllerState>(); 

    /// <summary> 
    /// Starts monitoring controller's connections and disconnections 
    /// </summary> 
    public void Start() 
    { 
        _watcher = new MotionControllerWatcher(); 
        _watcher.MotionControllerAdded += _watcher_MotionControllerAdded; 
        _watcher.MotionControllerRemoved += _watcher_MotionControllerRemoved; 
        var nowait = _watcher.StartAsync(); 
    } 

    /// <summary> 
    /// Stops monitoring controller's connections and disconnections 
    /// </summary> 
    public void Stop() 
    { 
        if (_watcher != null) 
        { 
            _watcher.MotionControllerAdded -= _watcher_MotionControllerAdded; 
            _watcher.MotionControllerRemoved -= _watcher_MotionControllerRemoved; 
            _watcher.Stop(); 
        } 
    }

    /// <summary> 
    /// called when a motion controller has been removed from the system: 
    /// Remove a motion controller from the cache 
    /// </summary> 
    /// <param name="sender">motion controller watcher</param> 
    /// <param name="e">motion controller </param> 
    private void _watcher_MotionControllerRemoved(object sender, MotionController e) 
    { 
        lock (_controllers) 
        { 
            _controllers.Remove(e.Handedness); 
        } 
    }

    /// <summary> 
    /// called when a motion controller has been added to the system: 
    /// Remove a motion controller from the cache 
    /// </summary> 
    /// <param name="sender">motion controller watcher</param> 
    /// <param name="e">motion controller </param> 
    private void _watcher_MotionControllerAdded(object sender, MotionController e) 
    { 
        lock (_controllers) 
        { 
            _controllers[e.Handedness] = new MotionControllerState(e); 
        } 
    } 
} 

Läsa nya indata efter avsökning

Du kan läsa det aktuella tillståndet för varje känd kontrollant via MotionController.TryGetReadingAtTime under uppdateringsmetoden för klassen MonoBehavior. Du vill skicka DateTime.Now som tidsstämpelparameter för att säkerställa att kontrollantens senaste tillstånd läses.

public class MotionControllerStateCache : MonoBehaviour 
{ 
    … 

    private class MotionControllerState 
    {
        … 

        /// <summary> 
        /// Update the current state of the motion controller 
        /// </summary> 
        /// <param name="when">time of the reading</param> 
        public void Update(DateTime when) 
        { 
            this.CurrentReading = this.MotionController.TryGetReadingAtTime(when); 
        } 

        /// <summary> 
        /// Last reading from the controller 
        /// </summary> 
        public MotionControllerReading CurrentReading { get; private set; } 
    } 

    /// <summary> 
    /// Updates the input states of the known motion controllers 
    /// </summary> 
    public void Update() 
    { 
        var now = DateTime.Now; 

        lock (_controllers) 
        { 
            foreach (var controller in _controllers) 
            { 
                controller.Value.Update(now); 
            } 
        } 
    } 
} 

Du kan hämta styrenheternas aktuella indatavärde med hjälp av handkontrollens handenhet:

public class MotionControllerStateCache : MonoBehaviour 
{ 
    … 
    /// <summary> 
    /// Returns the current value of a controller input such as button or trigger 
    /// </summary> 
    /// <param name="handedness">Handedness of the controller</param> 
    /// <param name="input">Button or Trigger to query</param> 
    /// <returns>float value between 0.0 (not pressed) and 1.0 
    /// (fully pressed)</returns> 
    public float GetValue(Handedness handedness, ControllerInput input) 
    { 
        MotionControllerReading currentReading = null; 

        lock (_controllers) 
        { 
            if (_controllers.TryGetValue(handedness, out MotionControllerState mc)) 
            { 
                currentReading = mc.CurrentReading; 
            } 
        } 

        return (currentReading == null) ? 0.0f : currentReading.GetPressedValue(input); 
    } 

    /// <summary> 
    /// Returns the current value of a controller input such as button or trigger 
    /// </summary> 
    /// <param name="handedness">Handedness of the controller</param> 
    /// <param name="input">Button or Trigger to query</param> 
    /// <returns>float value between 0.0 (not pressed) and 1.0 
    /// (fully pressed)</returns> 
    public float GetValue(UnityEngine.XR.WSA.Input.InteractionSourceHandedness handedness, ControllerInput input) 
    { 
        return GetValue(Convert(handedness), input); 
    } 

    /// <summary> 
    /// Returns a boolean indicating whether a controller input such as button or trigger is pressed 
    /// </summary> 
    /// <param name="handedness">Handedness of the controller</param> 
    /// <param name="input">Button or Trigger to query</param> 
    /// <returns>true if pressed, false if not pressed</returns> 
    public bool IsPressed(Handedness handedness, ControllerInput input) 
    { 
        return GetValue(handedness, input) >= PressedThreshold; 
    } 
} 

Om du till exempel vill läsa det analoga fattningsvärdet för en InteractionSource:

/// Read the analog grasp value of all connected interaction sources 
void Update() 
{ 
    … 
    var stateCache = gameObject.GetComponent<MotionControllerStateCache>(); 
    foreach (var sourceState in InteractionManager.GetCurrentReading()) 
    { 
        float graspValue = stateCache.GetValue(sourceState.source.handedness, 
            Microsoft.MixedReality.Input.ControllerInput.Grasp);
        … 
    }
} 

Generera händelser från de nya indata

I stället för att söka efter en kontrollants tillstånd en gång per bildruta kan du hantera alla tillståndsändringar som händelser, vilket gör att du kan hantera även de snabbaste åtgärderna som varar mindre än en ram. För att den här metoden ska fungera måste cachen för rörelsekontrollanter bearbeta alla tillstånd som publicerats av en kontrollant sedan den senaste ramen, vilket du kan göra genom att lagra tidsstämpeln för den senaste MotionControllerReading som hämtats från en MotionController och anropar MotionController.TryGetReadingAfterTime():

private class MotionControllerState 
{ 
    … 
    /// <summary> 
    /// Returns an array representng buttons which are pressed 
    /// </summary> 
    /// <param name="reading">motion controller reading</param> 
    /// <returns>array of booleans</returns> 
    private bool[] GetPressed(MotionControllerReading reading) 
    { 
        if (reading == null) 
        { 
            return null; 
        } 
        else 
        { 
            bool[] ret = new bool[this.pressableInputs.Length]; 
            for (int i = 0; i < pressableInputs.Length; ++i) 
            { 
                ret[i] = reading.GetPressedValue(pressableInputs[i]) >= PressedThreshold; 
            } 

            return ret; 
        } 
    } 

    /// <summary> 
    /// Get the next available state of the motion controller 
    /// </summary> 
    /// <param name="lastReading">previous reading</param> 
    /// <param name="newReading">new reading</param> 
    /// <returns>true is a new reading was available</returns> 
    private bool GetNextReading(MotionControllerReading lastReading, out MotionControllerReading newReading) 
    { 
        if (lastReading == null) 
        { 
            // Get the first state published by the controller 
            newReading = this.MotionController.TryGetReadingAfterSystemRelativeTime(TimeSpan.FromSeconds(0.0)); 
        } 
        else 
        { 
            // Get the next state published by the controller 
            newReading = this.MotionController.TryGetReadingAfterTime(lastReading.InputTime); 
        } 

        return newReading != null; 
    } 

    /// <summary> 
    /// Processes all the new states published by the controller since the last call 
    /// </summary> 
    public IEnumerable<MotionControllerEventArgs> GetNextEvents() 
    {
        MotionControllerReading lastReading = this.CurrentReading; 
        bool[] lastPressed = GetPressed(lastReading); 
        MotionControllerReading newReading; 
        bool[] newPressed; 

        while (GetNextReading(lastReading, out newReading)) 
        { 
            newPressed = GetPressed(newReading); 

            // If we have two readings, compare and generate events 
            if (lastPressed != null) 
            { 
                for (int i = 0; i < pressableInputs.Length; ++i) 
                { 
                    if (newPressed[i] != lastPressed[i]) 
                    { 
                        yield return new MotionControllerEventArgs(this.MotionController.Handedness, newPressed[i], this.pressableInputs[i], newReading.InputTime); 
                    } 
                } 
            } 

            lastPressed = newPressed; 
            lastReading = newReading; 
        } 

        // No more reading 
        this.CurrentReading = lastReading; 
    } 
} 

Nu när du har uppdaterat interna cacheklasser kan klassen MonoBehavior exponera två händelser – pressade och släppta – och hämta dem från metoden Update():

/// <summary> 
/// Event argument class for InputPressed and InputReleased events 
/// </summary> 
public class MotionControllerEventArgs : EventArgs 
{ 
    public MotionControllerEventArgs(Handedness handedness, bool isPressed, rollerInput input, DateTime inputTime) 
    { 
        this.Handedness = handedness; 
        this.Input = input; 
        this.InputTime = inputTime; 
        this.IsPressed = isPressed; 
    } 

    /// <summary> 
    /// Handedness of the controller raising the event 
    /// </summary> 
    public Handedness Handedness { get; private set; } 

    /// <summary> 
    /// Button pressed or released 
    /// </summary> 
    public ControllerInput Input { get; private set; } 

    /// <summary> 
    /// Time of the event 
    /// </summary> 
    public DateTime InputTime { get; private set; } 

    /// <summary> 
    /// true if button is pressed, false otherwise 
    /// </summary> 
    public bool IsPressed { get; private set; } 
} 

/// <summary> 
/// Event raised when a button is pressed 
/// </summary> 
public event EventHandler<MotionControllerEventArgs> InputPressed; 

/// <summary> 
/// Event raised when a button is released 
/// </summary> 
public event EventHandler<MotionControllerEventArgs> InputReleased; 

/// <summary> 
/// Updates the input states of the known motion controllers 
/// </summary> 
public void Update() 
{ 
    // If some event handler has been registered, we need to process all states  
    // since the last update, to avoid missing a quick press / release 
    if ((InputPressed != null) || (InputReleased != null)) 
    { 
        List<MotionControllerEventArgs> events = new <MotionControllerEventArgs>(); 

        lock (_controllers) 
        { 
            foreach (var controller in _controllers) 
            { 
                events.AddRange(controller.Value.GetNextEvents()); 
            } 
        } 
 
        // Sort the events by time 
        events.Sort((e1, e2) => DateTime.Compare(e1.InputTime, e2.InputTime)); 

        foreach (MotionControllerEventArgs evt in events) 
        { 
            if (evt.IsPressed && (InputPressed != null)) 
            { 
                InputPressed(this, evt); 
            } 
            else if (!evt.IsPressed && (InputReleased != null)) 
            { 
                InputReleased(this, evt); 
            } 
        } 
    } 
    else 
    { 
        // As we do not predict button presses and the timestamp of the next e is in the future 
        // DateTime.Now is correct in this context as it will return the latest e of controllers 
        // which is the best we have at the moment for the frame. 
        var now = DateTime.Now; 
        lock (_controllers) 
        { 
            foreach (var controller in _controllers) 
            { 
                controller.Value.Update(now); 
            } 
        } 
    } 
} 

Strukturen i kodexemplen ovan gör registreringen av händelser mycket mer läsbar:

public InteractionSourceHandedness handedness; 
public Microsoft.MixedReality.Input.ControllerInput redButton;

// Start of the Mono Behavior: register handlers for events from cache 
void Start() 
{ 
    var stateCache = gameObject.GetComponent<MotionControllerStateCache>(); 
    stateCache.InputPressed += stateCache_InputPressed; 
    stateCache.InputReleased += stateCache_InputReleased; 
    … 
} 

// Called when a button is released 
private void stateCache_InputReleased(object sender, MotionControllerStateCache.MotionControllerEventArgs e) 
{ 
    if ((e.SourceHandedness == handedness) && (e.Input == redButton)) 
    { 
        … 
    } 
} 

// Called when a button is pressed 
private void stateCache_InputPressed(object sender, MotionControllerStateCache.MotionControllerEventArgs e) 
{ 
    if ((e.SourceHandedness == handedness) && (e.Input == redButton)) 
    { 
        … 
    } 
} 

Se även