> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Créer une interface tactile native avec IGameInput

> Création d'une interface tactile native pour votre jeu avec IGameInput

Lorsque les joueurs diffusent votre jeu en streaming sur leurs appareils mobiles, l'un des meilleurs moyens d'accroître leur plaisir de jeu est de leur permettre d'interagir avec votre jeu à l'aide de commandes tactiles.  Le streaming de jeux XBOX prend en charge la superposition de commandes tactiles sur votre jeu à l'aide du [Touch Adaptation Kit](/fr/build/core-features/common/game-streaming/game-streaming-touch-touch-adaptation-kit-overview), ce qui peut être un excellent choix pour de nombreux écrans de votre jeu où une manette virtuelle constitue une façon naturelle de jouer. Toutefois, pour certaines parties de votre jeu, comme les menus, les cartes, les écrans d'inventaire et d'autres, il peut être plus naturel d'interagir directement avec le jeu au moyen d'entrées tactiles.

Par exemple, il est très naturel pour un joueur de vouloir appuyer sur les options de menu pour interagir avec elles, ou d'utiliser les gestes d'un téléphone mobile pour zoomer et faire défiler une carte.  Le Microsoft Game Development Kit (GDK) fournit des API qui vous permettent d'intégrer cette interface tactile native à votre jeu, afin qu'il offre une véritable expérience mobile.

Le Touch Adaptation Kit et l'entrée tactile native ne s'excluent pas mutuellement : vous pouvez utiliser les deux dans votre jeu, en employant chaque forme d'entrée tactile là où elle est la plus pertinente pour votre titre. Par exemple, utiliser des menus tactiles natifs tout en utilisant le Touch Adaptation Kit pour la boucle de gameplay principale peut être une façon raisonnable de structurer la stratégie d'entrée tactile de votre titre.

<Note>Veuillez informer votre gestionnaire de compte si vous créez un jeu avec entrée tactile native.  Les services back-end de XBOX Game Streaming devront être configurés pour permettre à votre jeu de recevoir des événements tactiles lorsqu'il sera déployé dans des environnements commerciaux.</Note>

L'entrée tactile native est mise à la disposition de votre jeu via l'API [IGameInputReading::GetTouchState](/fr/reference/input/gameinput/deprecated/interfaces/igameinputreading/methods/igameinputreading_gettouchstate). Cette API vous fournit l'ensemble actuel des points de contact représentant les doigts avec lesquels le joueur touche actuellement l'écran.

Pour convertir ces points de contact en événements d'appui, de déplacement et de relâchement, il peut être utile de suivre leur état d'une frame à l'autre.

* Tout point de contact absent de la frame précédente mais présent dans la frame actuelle constitue un nouvel appui tactile.
* Tout point de contact présent dans la frame précédente et toujours présent dans la frame actuelle constitue soit un déplacement, soit une absence d'opération si les coordonnées du contact n'ont pas changé.
* Les points de contact présents dans la frame précédente mais qui ne le sont plus constituent un relâchement tactile.

Une boucle d'entrée très simple permettant de générer ces événements d'appui, de déplacement et de relâchement pourrait ressembler à ce qui suit :

```cpp theme={null}
struct TouchPoint
{
    // GameInputTouchState.touchId corresponding to this point
    uint64_t Id = 0;    

    // X pixel being touched
    uint32_t X = 0;

    // Y pixel being touched
    uint32_t Y = 0;

    // Is this entry in the array of touch points currently being used to track a touch
    bool IsInUse = false;

    // Is this TouchPoint tracking a finger which is currently touching the screen
    bool IsTouchActive = false;
};

// Touch points currently being tracked
std::array<TouchPoint, 10> g_touchPoints = {};

extern IGameInput* g_gameInput;
extern uint32_t g_frameWidth;
extern uint32_t g_frameHeight;

void TouchPointPressed(const TouchPoint& touchPoint);
void TouchPointMoved(const TouchPoint& touchPoint);
void TouchPointReleased(const TouchPoint& touchPoint);


void ProcessTouchInput()
{
    // Reset the active touch state from the previous frame
    for (TouchPoint& touchPoint : g_touchPoints)
    {
        touchPoint.IsTouchActive = false;
    }

    // Process any new touch points for this frame
    Microsoft::WRL::ComPtr<IGameInputReading> reading = nullptr;
    if (SUCCEEDED(g_gameInput->GetCurrentReading(GameInputKindTouch, nullptr, &reading)))
    {
        uint32_t touchCount = reading->GetTouchCount();
        if (touchCount > 0)
        {
            std::vector<GameInputTouchState> touchStates(touchCount);
            touchCount = reading->GetTouchState(touchCount, touchStates.data());

            for (const GameInputTouchState& touchState : touchStates)
            {
                const uint32_t x = static_cast<uint32_t>(touchState.positionX * g_frameWidth);
                const uint32_t y = static_cast<uint32_t>(touchState.positionY * g_frameHeight);

                // Check to see if we are already tracking this touch point
                auto existingPoint = std::find_if(std::begin(g_touchPoints), std::end(g_touchPoints), [id = touchState.touchId](const TouchPoint& point)
                {
                    return point.IsInUse && point.Id == id;
                });

                if (existingPoint != g_touchPoints.end())
                {
                    // We were already tracking the point - it is still alive this frame, but it may have
                    // also moved position.
                    existingPoint->IsTouchActive = true;
                    if (existingPoint->X != x || existingPoint->Y != y)
                    {
                        existingPoint->X = x;
                        existingPoint->Y = y;
                        TouchPointMoved(*existingPoint);
                    }
                }
                else
                {
                    // This is a new touch point. Start tracking it and treat it as a press
                    auto insertPoint = std::find_if(std::begin(g_touchPoints), std::end(g_touchPoints), [](const TouchPoint& point)
                    {
                        return !point.IsInUse;
                    });

                    if (insertPoint != std::end(g_touchPoints))
                    {
                        insertPoint->Id = touchState.touchId;
                        insertPoint->X = x;
                        insertPoint->Y = y;
                        insertPoint->IsInUse = true;
                        insertPoint->IsTouchActive = true;

                        TouchPointPressed(*insertPoint);
                    }
                }
            }
        }

        // Look for any points which were pressed last frame but are no longer pressed this frame
        // and treat those as touch releases
        for (TouchPoint& touchPoint : g_touchPoints)
        {
            if (touchPoint.IsInUse && !touchPoint.IsTouchActive)
            {
                TouchPointReleased(touchPoint);
                touchPoint = TouchPoint{};
            }
        }
    }
}
```


## Related topics

- [Build a native touch interface with IGameInput](/build/core-features/common/game-streaming/game-streaming-native-touch-igameinput.md)
- [IGameInputReading::GetTouchCount](/es/reference/input/gameinput/deprecated/interfaces/igameinputreading/methods/igameinputreading_gettouchcount.md)
- [IGameInputReading::GetTouchState](/es/reference/input/gameinput/deprecated/interfaces/igameinputreading/methods/igameinputreading_gettouchstate.md)
- [Getting started with touch](/build/core-features/common/game-streaming/game-streaming-getting-started-with-touch.md)
- [Aperçu de Windows et ROG XBOX Ally](/fr-CA/paths/windows/overview.md)