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.
- Grip är nu en utlösare som publicerar en ström med värden mellan 0.0 och 1.0 i stället för en knapp med lägena Trycks inte och Inte pressad.
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 hjälp av 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örelsekontrollant. 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 kontrollanten, inklusive knappar, utlösare, 2D-axel och tumsticka. Klassen MotionController exponerar också metoder för att komma åt 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 Mixed Reality-indatapaketet i kategorin Mixed Reality Toolkit:
Använda Microsoft.MixedReality.Input
Indatavärden
En MotionController kan exponera två typer av indata:
- Knappar och utlösartillstånd uttrycks med ett unikt flyttalsvärde mellan 0,0 och 1,0 som anger hur mycket de trycks på.
- 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 med indata som returnerar ett nedtryckt värde (knappar och utlösare) eller metoden MotionController.GetXYInputs() för att returnera en lista med 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 ett GameObject enligt 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 kontrollanternas aktuella indatavärde med 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 bildruta. För att den här metoden ska fungera måste cacheminnet 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 de interna cacheklasserna kan klassen MonoBehavior exponera två händelser – pressade och utgivna – och generera dem från dess Update()-metod:
/// <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 det mycket mer lättläst att registrera händelser:
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))
{
…
}
}