HP Reverb G2 Controllers in Unity
Os controladores de movimento HP são um novo tipo de controladores Windows Mixed Reality: todas as mesmas tecnologias de controlo com um conjunto ligeiramente diferente de entradas disponíveis:
- O touchpad foi substituído por dois botões: A e B para o comando direito e X e Y para o comando esquerdo.
- O Comando é agora um acionador que publica um fluxo de valores entre 0,0 e 1.0 em vez de um botão com estados Premidos e Não Premidos.
Uma vez que as novas entradas não estão acessíveis através das APIs existentes do Windows e do Unity, precisa do Pacote UPM Microsoft.MixedReality.Input dedicado.
Importante
As classes neste pacote não substituem as APIs existentes do Windows e do Unity, mas complementam-nas. Normalmente, as funcionalidades disponíveis para controladores de Windows Mixed Reality clássicos e controladores de movimento HP são acessíveis através do mesmo caminho de código através de APIs existentes. Apenas as novas entradas requerem a utilização do pacote Microsoft.MixedReality.Input adicional.
Descrição geral do Controlador de Movimento HP
Microsoft.MixedReality.Input.MotionController representa um controlador de movimento. Cada instância do MotionController tem um XR. WSA. Elemento da rede Input.InteractionSource , que pode ser correlacionado com a entrega, o ID do fornecedor, o ID do produto e a versão.
Pode utilizar instâncias do MotionController ao criar um MotionControllerWatcher e subscrever os seus eventos, semelhante à utilização de eventos InteractionManager para detetar novas instâncias do InteractionSource . Os métodos e propriedades do MotionController descrevem as entradas suportadas pelo controlador, incluindo os botões, os acionadores, o eixo 2D e o thumbstick. A classe MotionController também expõe métodos para aceder a estados de entrada através da classe MotionControllerReading . A classe MotionControllerReading representa um instantâneo do estado do controlador num determinado momento.
Instalar Microsoft.MixedReality.Input com a Ferramenta de Funcionalidades do Mixed Reality
Instale o plug-in Microsoft.MixedReality.Input com a nova aplicação Mixed Reality Feature Tool. Siga as instruções de instalação e utilização e selecione o pacote de entrada Mixed Reality na categoria Mixed Reality Toolkit:
Utilizar Microsoft.MixedReality.Input
Valores de entrada
Um MotionController pode expor dois tipos de entradas:
- Os botões e os estados do acionador são expressos por um valor flutuante exclusivo entre 0,0 e 1,0 que indica a quantidade de pressão.
- Um botão só pode devolver 0,0 (quando não premido) ou 1,0 (quando premido), enquanto um acionador pode devolver valores contínuos entre 0,0 (totalmente libertado) e 1,0 (totalmente premido).
- O estado do thumbstick é expresso por um Vector2 cujos componentes X e Y estão entre -1.0 e 1.0.
Pode utilizar MotionController.GetPressableInputs() para devolver uma lista de entradas que devolvem um valor premido (botões e acionadores) ou o método MotionController.GetXYInputs() para devolver uma lista de entradas que devolvem um valor de dois eixos.
Uma instância motionControllerReading representa o estado do controlador num determinado momento:
- GetPressedValue() obtém o estado de um botão ou de um acionador.
- GetXYValue() obtém o estado de um manípulo.
Criar uma cache para manter uma coleção de instâncias do MotionController e respetivos estados
Comece por instanciar um MotionControllerWatcher e registar processadores para os eventos MotionControllerAdded e MotionControllerRemoved para manter uma cache de instâncias do MotionController disponíveis. Esta 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);
}
}
}
Ler novas entradas por consulta
Pode ler o estado atual de cada controlador conhecido através de MotionController.TryGetReadingAtTime durante o método Update da classe MonoBehavior. Quer transmitir DateTime.Now como o parâmetro de carimbo de data/hora para garantir que o estado mais recente do controlador é 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);
}
}
}
}
Pode obter o valor de entrada atual dos controladores com a Funcionalidade 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ógico de uma 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);
…
}
}
Gerar eventos a partir das novas entradas
Em vez de consultar o estado de um controlador uma vez por fotograma, tem a opção de processar todas as alterações de estado como eventos, o que lhe permite lidar com as ações mais rápidas que duram menos do que um fotograma. Para que esta abordagem funcione, a cache de controladores de movimento tem de processar todos os estados publicados por um controlador desde o último fotograma, o que pode fazer ao armazenar o carimbo de data/hora do último MotionControllerReading obtido a partir de um MotionController e ao chamar 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 atualizou as classes internas da cache, a classe MonoBehavior pode expor dois eventos – Premidos e Lançados – e criá-los a partir do respetivo 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 registo 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))
{
…
}
}