HP Reverb G2-Controller in Unity
HP Motion Controller sind ein brandneuer Typ von Windows Mixed Reality Controllern: alle die gleiche Tracking-Technologie mit einem etwas anderen Satz verfügbarer Eingaben:
- Touchpad wurde durch zwei Tasten ersetzt: A und B für den rechten Controller und X und Y für den linken Controller.
- Die Greiffläche ist jetzt ein Trigger, der einen Datenstrom von Werten zwischen 0,0 und 1,0 statt einer Schaltfläche mit gedrückten und nicht gedrückten Zuständen veröffentlicht.
Da die neuen Eingaben nicht über vorhandene Windows und Unity-APIs zugänglich sind, benötigen Sie das dedizierte Microsoft.MixedReality.Input UPM-Paket.
Wichtig
Klassen in diesem Paket ersetzen keine vorhandenen Windows- und Unity-APIs, sondern ergänzen sie. Häufig verfügbare Features für klassische Windows Mixed Reality-Controller und HP Motion Controller sind über denselben Codepfad mit vorhandenen APIs zugänglich. Nur die neuen Eingaben erfordern die Verwendung des zusätzlichen Microsoft.MixedReality.Input-Pakets.
HP Motion Controller –Übersicht
Microsoft.MixedReality.Input.MotionController stellt einen Bewegungscontroller dar. Jede MotionController-Instanz verfügt über einen XR. WSA. Input.InteractionSource-Peer , der mit Händigkeit, Anbieter-ID, Produkt-ID und Version korreliert werden kann.
Sie können MotionController-Instanzen abrufen, indem Sie eine MotionControllerWatcher erstellen und seine Ereignisse abonnieren, ähnlich wie die Verwendung von InteractionManager-Ereignissen zum Ermitteln neuer InteractionSource-Instanzen . Die Methoden und Eigenschaften des MotionControllers beschreiben die vom Controller unterstützten Eingaben, einschließlich der Schaltflächen, Trigger, 2D-Achse und Fingerabdruckstick. Die MotionController-Klasse macht auch Methoden für den Zugriff auf Eingabezustände über die MotionControllerReading-Klasse verfügbar. Die MotionControllerReading-Klasse stellt eine Momentaufnahme des Zustands des Controllers zu einem bestimmten Zeitpunkt dar.
Installieren von Microsoft.MixedReality.Input mit dem Mixed Reality Featuretool
Installieren Sie das Microsoft.MixedReality.Input-Plug-In mit der neuen Mixed Reality Featuretool-Anwendung. Folgen Sie den Installations- und Verwendungsanweisungen, und wählen Sie das Mixed Reality Eingabepaket in der Kategorie "Mixed Reality Toolkit" aus:
Verwenden von Microsoft.MixedReality.Input
Eingabewerte
Ein MotionController kann zwei Arten von Eingaben verfügbar machen:
- Schaltflächen und Triggerzustände werden durch einen eindeutigen Floatwert zwischen 0,0 und 1,0 ausgedrückt, der angibt, wie viel sie gedrückt werden.
- Eine Schaltfläche kann nur 0,0 (wenn nicht gedrückt) oder 1,0 (wenn gedrückt) zurückgegeben werden, während ein Trigger fortlaufende Werte zwischen 0,0 (vollständig losgelassen) auf 1,0 zurückzugeben kann (vollständig gedrückt).
- Der Fingerabdruckzustand wird von einem Vector2 ausgedrückt, dessen X- und Y-Komponenten zwischen -1,0 und 1,0 liegen.
Sie können MotionController.GetPressableInputs() verwenden, um eine Liste der Eingaben zurückzugeben, die einen gedrückten Wert (Schaltflächen und Trigger) oder die MotionController.GetXYInputs() -Methode zurückgeben, um eine Liste der Eingaben zurückzugeben, die einen 2-Achsen-Wert zurückgeben.
Eine MotionControllerReading-Instanz stellt den Status des Controllers zu einem bestimmten Zeitpunkt dar:
- GetPressedValue() ruft den Status einer Schaltfläche oder eines Triggers ab.
- GetXYValue() ruft den Zustand eines Fingerabdrucksticks ab.
Erstellen eines Caches zum Verwalten einer Sammlung von MotionController-Instanzen und deren Zustände
Beginnen Sie, indem Sie eine MotionControllerWatcher instanziieren und Handler für seine MotionControllerAdded - und MotionControllerRemoved-Ereignisse registrieren, um einen Cache der verfügbaren MotionController-Instanzen beizubehalten. Dieser Cache sollte ein MonoBehavior sein, der an ein GameObject angefügt ist, wie im folgenden Code gezeigt:
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);
}
}
}
Lesen neuer Eingaben durch Abfragen
Sie können den aktuellen Status jeder bekannten Controller über MotionController.TryGetReadingAtTime während der Update-Methode der MonoBehavior-Klasse lesen. Sie möchten DateTime.Now als Timestamp-Parameter übergeben, um sicherzustellen, dass der neueste Zustand des Controllers gelesen wird.
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);
}
}
}
}
Sie können den aktuellen Eingabewert der Controller mithilfe der Händigkeit des Controllers erfassen:
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;
}
}
So lesen Sie z. B. den analogen Greifwert einer 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);
…
}
}
Generieren von Ereignissen aus den neuen Eingaben
Anstatt einmal pro Frame den Status eines Controllers abzufragen, haben Sie die Möglichkeit, alle Statusänderungen als Ereignisse zu behandeln, wodurch Sie sogar die schnellsten Aktionen behandeln können, die weniger als ein Frame dauern. Damit dieser Ansatz funktioniert, muss der Cache von Bewegungscontrollern alle Zustände verarbeiten, die von einem Controller seit dem letzten Frame veröffentlicht wurden, was Sie tun können, indem Sie den Zeitstempel des letzten MotionControllerReading speichern, der von einem MotionController abgerufen wurde und MotionController aufruft.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;
}
}
Nachdem Sie die internen Cacheklassen aktualisiert haben, kann die MonoBehavior-Klasse zwei Ereignisse verfügbar machen – pressed and Release – und lösen Sie sie aus der Update() -Methode aus:
/// <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);
}
}
}
}
Die Struktur in den obigen Codebeispielen macht die Registrierung von Ereignissen wesentlich besser lesbar:
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))
{
…
}
}