Partager via

Entrée clavier, souris et contrôleur (C++)

Cet article concerne les API winRT natives héritées. Pour les nouveaux projets d’application native, nous vous recommandons d’utiliser l’API OpenXR.

Les extraits de code de cet article illustrent actuellement l’utilisation de C++/CX plutôt que C++/WinRT conforme À C++/WinRT, tel qu’utilisé dans le modèle de projet holographique C++. Les concepts sont équivalents pour un projet C++/WinRT, mais vous devez traduire le code.

S’abonner aux événements d’entrée CoreWindow

Entrée au clavier

Dans le modèle d’application Windows Holographic, nous incluons un gestionnaire d’événements pour l’entrée au clavier comme n’importe quelle autre application UWP. Votre application utilise les données d’entrée du clavier de la même façon dans Windows Mixed Reality.

À partir de AppView.cpp :

// Register for keypress notifications.
   window->KeyDown +=
       ref new TypedEventHandler<CoreWindow^, KeyEventArgs^>(this, &AppView::OnKeyPressed);

    …

   // Input event handlers

   void AppView::OnKeyPressed(CoreWindow^ sender, KeyEventArgs^ args)
   {
       //
       // TODO: Respond to keyboard input here.
       //
   }

Entrée du clavier virtuel

Pour les casques de bureau immersifs, vous pouvez prendre en charge les claviers virtuels rendus par Windows sur votre vue immersive en implémentant CoreTextEditContext. Cela permet à Windows de comprendre l’état de vos propres zones de texte rendues par l’application, afin que le clavier virtuel puisse contribuer correctement au texte.

Pour plus d’informations sur l’implémentation de la prise en charge de CoreTextEditContext, consultez l’exemple CoreTextEditContext.

Entrée de la souris

Vous pouvez également utiliser l’entrée de la souris, à nouveau via les gestionnaires d’événements d’entrée UWP CoreWindow. Voici comment modifier le modèle d’application Windows Holographique pour prendre en charge les clics de souris de la même façon que les mouvements appuyés. Après avoir apporté cette modification, un clic de souris tout en portant un casque immersif repositionne le cube.

Remarque

Les applications UWP peuvent également obtenir des données XY brutes pour la souris à l’aide de l’API MouseDevice .

Commencez par déclarer un nouveau gestionnaire OnPointerPressed dans AppView.h :

protected:
       void OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);

Dans AppView.cpp, ajoutez ce code à SetWindow :

// Register for pointer pressed notifications.
   window->PointerPressed +=
       ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &AppView::OnPointerPressed);

Ensuite, placez cette définition pour OnPointerPressed au bas du fichier :

void AppView::OnPointerPressed(CoreWindow^ sender, PointerEventArgs^ args)
   {
       // Allow the user to interact with the holographic world using the mouse.
       if (m_main != nullptr)
       {
           m_main->OnPointerPressed();
       }
   }

Le gestionnaire d’événements que nous venons d’ajouter est un pass-through au modèle main classe. Nous allons modifier la classe main pour prendre en charge cette transmission directe. Ajoutez cette déclaration de méthode publique au fichier d’en-tête :

// Handle mouse input.
       void OnPointerPressed();

Vous aurez également besoin de cette variable membre privée :

// Keep track of mouse input.
       bool m_pointerPressed = false;

Enfin, nous allons mettre à jour la classe main avec une nouvelle logique pour prendre en charge les clics de souris. Commencez par ajouter ce gestionnaire d’événements. Veillez à mettre à jour le nom de la classe :

void MyHolographicAppMain::OnPointerPressed()
   {
       m_pointerPressed = true;
   }

Maintenant, dans la méthode Update, remplacez la logique existante pour obtenir une pose de pointeur par ceci :

SpatialInteractionSourceState^ pointerState = m_spatialInputHandler->CheckForInput();
   SpatialPointerPose^ pose = nullptr;
   if (pointerState != nullptr)
   {
       pose = pointerState->TryGetPointerPose(currentCoordinateSystem);
   }
   else if (m_pointerPressed)
   {
       pose = SpatialPointerPose::TryGetAtTimestamp(currentCoordinateSystem, prediction->Timestamp);
   }
   m_pointerPressed = false;

Recompiler et redéployer. Notez que le clic de souris repositionne désormais le cube dans votre casque immersif ou HoloLens avec la souris Bluetooth attachée.

Prise en charge du contrôleur de jeu

Les contrôleurs de jeu peuvent être un moyen amusant et pratique de permettre à l’utilisateur de contrôler une expérience immersive Windows Mixed Reality.

ajoutez les déclarations de membre privé suivantes à la classe d’en-tête de votre fichier main :

// Recognize gamepads that are plugged in after the app starts.
       void OnGamepadAdded(Platform::Object^, Windows::Gaming::Input::Gamepad^ args);

// Stop looking for gamepads that are unplugged.
       void OnGamepadRemoved(Platform::Object^, Windows::Gaming::Input::Gamepad^ args);

Windows::Foundation::EventRegistrationToken                     m_gamepadAddedEventToken;
       Windows::Foundation::EventRegistrationToken                     m_gamepadRemovedEventToken;

// Keeps track of a gamepad and the state of its A button.
       struct GamepadWithButtonState
       {
           Windows::Gaming::Input::Gamepad^ gamepad;
           bool buttonAWasPressedLastFrame = false;
       };
       std::vector<GamepadWithButtonState>                             m_gamepads;

Initialisez les événements de boîtier de commande et tous les boîtiers de commande actuellement attachés dans le constructeur de votre classe main :

// If connected, a game controller can also be used for input.
   m_gamepadAddedEventToken = Gamepad::GamepadAdded +=
       ref new EventHandler<Gamepad^>(
           bind(&$safeprojectname$Main::OnGamepadAdded, this, _1, _2)
           );

m_gamepadRemovedEventToken = Gamepad::GamepadRemoved +=
       ref new EventHandler<Gamepad^>(
           bind(&$safeprojectname$Main::OnGamepadRemoved, this, _1, _2)
           );

for (auto const& gamepad : Gamepad::Gamepads)
   {
       OnGamepadAdded(nullptr, gamepad);
   }

Ajoutez ces gestionnaires d’événements à votre classe main. Veillez à mettre à jour le nom de la classe :

void MyHolographicAppMain::OnGamepadAdded(Object^, Gamepad^ args)
   {
       for (auto const& gamepadWithButtonState : m_gamepads)
       {
           if (args == gamepadWithButtonState.gamepad)
           {
               // This gamepad is already in the list.
               return;
           }
       }
       m_gamepads.push_back({ args, false });
   }

void MyHolographicAppMain::OnGamepadRemoved(Object^, Gamepad^ args)
   {
       m_gamepads.erase(
           std::remove_if(m_gamepads.begin(), m_gamepads.end(), [&](GamepadWithButtonState& gamepadWithState)
               {
                   return gamepadWithState.gamepad == args;
               }),
           m_gamepads.end());
   }

Enfin, mettez à jour la logique d’entrée pour reconnaître les modifications apportées à l’état du contrôleur. Ici, nous utilisons la même variable m_pointerPressed décrite dans la section ci-dessus pour ajouter des événements de souris. Ajoutez ceci à la méthode Update, juste avant l’endroit où elle recherche SpatialPointerPose :

// Check for new input state since the last frame.
   for (auto& gamepadWithButtonState : m_gamepads)
   {
       bool buttonDownThisUpdate = ((gamepadWithButtonState.gamepad->GetCurrentReading().Buttons & GamepadButtons::A) == GamepadButtons::A);
       if (buttonDownThisUpdate && !gamepadWithButtonState.buttonAWasPressedLastFrame)
       {
           m_pointerPressed = true;
       }
       gamepadWithButtonState.buttonAWasPressedLastFrame = buttonDownThisUpdate;
   }

// For context.
   SpatialInteractionSourceState^ pointerState = m_spatialInputHandler->CheckForInput();
   SpatialPointerPose^ pose = nullptr;
   if (pointerState != nullptr)
   {
       pose = pointerState->TryGetPointerPose(currentCoordinateSystem);
   }
   else if (m_pointerPressed)
   {
       pose = SpatialPointerPose::TryGetAtTimestamp(currentCoordinateSystem, prediction->Timestamp);
   }
   m_pointerPressed = false;

N’oubliez pas de désinscrire les événements lors du nettoyage de la classe main :

if (m_gamepadAddedEventToken.Value != 0)
   {
       Gamepad::GamepadAdded -= m_gamepadAddedEventToken;
   }
   if (m_gamepadRemovedEventToken.Value != 0)
   {
       Gamepad::GamepadRemoved -= m_gamepadRemovedEventToken;
   }

Recompiler et redéployer. Vous pouvez maintenant attacher ou coupler un contrôleur de jeu et l’utiliser pour repositionner le cube tournant.

Voir aussi