Créer une interface tactile native avec IGameInput

Lorsque les joueurs diffusent votre jeu en continu sur leurs appareils mobiles, l’une des meilleures façons d’accroître leur plaisir de jeu est de leur permettre d’interagir avec votre jeu au moyen de commandes tactiles. La diffusion de jeux en continu XBOX permet de superposer des commandes tactiles à votre jeu au moyen du Touch Adaptation Kit, 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 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 toucher les options d’un menu pour interagir avec elles, ou d’utiliser les gestes des téléphones mobiles pour zoomer sur une carte et la faire défiler. Le Microsoft Game Development Kit (GDK) fournit des API qui vous permettent d’intégrer cette interface tactile native à votre jeu, pour qu’il offre une expérience véritablement 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 logique pour votre titre. Par exemple, utiliser des menus tactiles natifs tout en utilisant le Touch Adaptation Kit pour la boucle de jeu principale pourrait être une façon raisonnable de structurer la stratégie d’entrée tactile de votre titre.

Veuillez aviser votre gestionnaire de compte si vous créez un jeu avec l’entrée tactile native. Les services principaux de XBOX Game Streaming devront être configurés pour permettre à votre jeu de recevoir des événements tactiles lorsqu’il sera déployé dans les environnements de vente au détail.

L’entrée tactile native est mise à la disposition de votre jeu au moyen de l’API 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 image à l’autre.

Tout point de contact qui n’était pas présent dans l’image précédente, mais qui est présent dans l’image actuelle, est un nouvel appui tactile
Tout point de contact présent dans l’image précédente et toujours présent dans l’image actuelle est soit un déplacement, soit une opération sans effet si les coordonnées du contact n’ont pas changé.
Les points de contact qui étaient présents dans l’image précédente, mais qui ne le sont plus, constituent un relâchement tactile.

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

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{};
            }
        }
    }
}

Introduction

Onboarding & Access

Setup & Install

Build Your First Title