Controladores do HP Reverb G2 no Unity
Os controladores HP Motion são um novo tipo de controladores de Windows Mixed Reality: toda a mesma tecnologia de rastreamento com um conjunto ligeiramente diferente de entradas disponíveis:
- O Touchpad foi substituído por dois botões: A e B para o controlador direito e X e Y para o controlador esquerdo.
- O Grasp agora é um gatilho que publica um fluxo de valores entre 0,0 e 1,0 em vez de um botão com os estados Pressionado e Não Pressionado.
Como as novas entradas não são acessíveis por meio de APIs existentes do Windows e do Unity, você precisa do pacote UPM dedicado Microsoft.MixedReality.Input .
Importante
As classes neste pacote não substituem as APIs existentes do Windows e do Unity, mas as complementam. Os recursos comumente disponíveis para controladores de Windows Mixed Reality clássicos e controladores de movimento HP são acessíveis por meio do mesmo caminho de código usando APIs existentes. Somente as novas entradas exigem o uso do pacote adicional Microsoft.MixedReality.Input.
Visão geral do HP Motion Controller
Microsoft.MixedReality.Input.MotionController representa um controlador de movimento. Cada instância motioncontroller tem um XR. WSA. Par Input.InteractionSource , que pode ser correlacionado usando entrega, ID do fornecedor, ID do produto e versão.
Você pode pegar instâncias motioncontroller criando um MotionControllerWatcher e assinando seus eventos, semelhante ao uso de eventos InteractionManager para descobrir novas instâncias InteractionSource . Os métodos e as propriedades do MotionController descrevem as entradas compatíveis com o controlador, incluindo seus botões, gatilhos, eixo 2D e thumbstick. A classe MotionController também expõe métodos para acessar estados de entrada por meio da classe MotionControllerReading . A classe MotionControllerReading representa uma instantâneo do estado do controlador em um determinado momento.
Instalando o Microsoft.MixedReality.Input com a ferramenta de recursos Realidade Misturada
Instale o plug-in Microsoft.MixedReality.Input com o novo aplicativo Realidade Misturada Feature Tool. Siga as instruções de instalação e uso e selecione o pacote de entrada Realidade Misturada na categoria kit de ferramentas do Realidade Misturada:
Usando Microsoft.MixedReality.Input
Valores de entrada
Um MotionController pode expor dois tipos de entradas:
- Botões e estados de gatilho são expressos por um valor float exclusivo entre 0,0 e 1,0 que indica o quanto eles são pressionados.
- Um botão só pode retornar 0,0 (quando não pressionado) ou 1,0 (quando pressionado), enquanto um gatilho pode retornar valores contínuos entre 0,0 (totalmente liberado) e 1,0 (totalmente pressionado).
- O estado do thumbstick é expresso por um Vector2 cujos componentes X e Y estão entre -1.0 e 1.0.
Você pode usar MotionController.GetPressableInputs() para retornar uma lista de entradas que retornam um valor pressionado (botões e gatilhos) ou o método MotionController.GetXYInputs() para retornar uma lista de entradas que retornam um valor de dois eixos.
Uma instância MotionControllerReading representa o estado do controlador em um determinado momento:
- GetPressedValue() recupera o estado de um botão ou um gatilho.
- GetXYValue() recupera o estado de um thumbstick.
Criando um cache para manter uma coleção de instâncias MotionController e seus estados
Comece instanciando um MotionControllerWatcher e registrando manipuladores para seus eventos MotionControllerAdded e MotionControllerRemoved para manter um cache de instâncias MotionController disponíveis. Esse cache deve ser um MonoBehavior anexado a um GameObject, conforme demonstrado no seguinte código:
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);
}
}
}
Lendo novas entradas por sondagem
Você pode ler o estado atual de cada controlador conhecido por meio de MotionController.TryGetReadingAtTime durante o método Update da classe MonoBehavior. Você deseja passar DateTime.Now como o parâmetro de carimbo de data/hora para garantir que o estado mais recente do controlador seja lido.
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);
}
}
}
}
Você pode obter o valor de entrada atual dos controladores usando o Handedness do controlador:
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;
}
}
Por exemplo, para ler o valor de compreensão analógica de um 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);
…
}
}
Gerando eventos das novas entradas
Em vez de sondar o estado de um controlador uma vez por quadro, você tem a opção de lidar com todas as alterações de estado como eventos, o que permite manipular até mesmo as ações mais rápidas com duração inferior a um quadro. Para que essa abordagem funcione, o cache de controladores de movimento precisa processar todos os estados publicados por um controlador desde o último quadro, o que você pode fazer armazenando o carimbo de data/hora do último MotionControllerReading recuperado de um MotionController e chamando 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;
}
}
Agora que você atualizou as classes internas de cache, a classe MonoBehavior pode expor dois eventos – Pressionado e Liberado – e acioná-los a partir de seu método 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);
}
}
}
}
A estrutura nos exemplos de código acima torna o registro de eventos muito mais legível:
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))
{
…
}
}