input gestures

★★☆☆by Ramon Santamaria (@raysan5)

There is no browser build of this example yet.

Is it the same as C?

Desktop:verified The Zig version renders a final frame that is byte-identical to the C example.
Browser:not checked yet The browser comparison does not cover this example yet.

ZigC (original)

//! raylib [core] example - input gestures
//!
//! Zig-API translation of examples/core/core_input_gestures.c (raylib 6.2).
//! Example licensed under an unmodified zlib/libpng license.
//! Copyright (c) 2016-2025 Ramon Santamaria (@raysan5)

const rl = @import("raylib");

const max_gesture_strings = 20;

pub fn main() void {
    // Initialization
    const screen_width = 800;
    const screen_height = 450;

    rl.initWindow(screen_width, screen_height, "raylib [core] example - input gestures");
    defer rl.closeWindow(); // Close window and OpenGL context

    var touch_position: rl.Vector2 = .{ .x = 0, .y = 0 };
    const touch_area: rl.Rectangle = .{ .x = 220, .y = 10, .width = screen_width - 230.0, .height = screen_height - 20.0 };

    var gestures_count: usize = 0;
    var gesture_strings: [max_gesture_strings][:0]const u8 = @splat("");

    var current_gesture: rl.Gesture = .none;
    var last_gesture: rl.Gesture = .none;

    //rl.setGesturesEnabled(0b0000000000001001); // Enable only some gestures to be detected

    rl.setTargetFPS(60); // Set our game to run at 60 frames-per-second

    // Main game loop
    while (!rl.windowShouldClose()) { // Detect window close button or ESC key
        // Update
        last_gesture = current_gesture;
        current_gesture = rl.getGestureDetected();
        touch_position = rl.getTouchPosition(0);

        if (rl.checkCollisionPointRec(touch_position, touch_area) and current_gesture != .none) {
            if (current_gesture != last_gesture) {
                // Store gesture string
                if (gestureName(current_gesture)) |name| gesture_strings[gestures_count] = name;

                gestures_count += 1;

                // Reset gestures strings
                if (gestures_count >= max_gesture_strings) {
                    gesture_strings = @splat("");
                    gestures_count = 0;
                }
            }
        }

        // Draw
        rl.beginDrawing();
        defer rl.endDrawing();

        rl.clearBackground(.ray_white);

        rl.drawRectangleRec(touch_area, .gray);
        rl.drawRectangle(225, 15, screen_width - 240, screen_height - 30, .ray_white);

        rl.drawText("GESTURES TEST AREA", screen_width - 270, screen_height - 40, 20, rl.fade(.gray, 0.5));

        for (gesture_strings[0..gestures_count], 0..) |gesture_string, i| {
            const y: i32 = @intCast(20 * i);
            const alpha: f32 = if (i % 2 == 0) 0.5 else 0.3;
            rl.drawRectangle(10, 30 + y, 200, 20, rl.fade(.light_gray, alpha));

            const color: rl.Color = if (i < gestures_count - 1) .dark_gray else .maroon;
            rl.drawText(gesture_string, 35, 36 + y, 10, color);
        }

        rl.drawRectangleLines(10, 29, 200, screen_height - 50, .gray);
        rl.drawText("DETECTED GESTURES", 50, 15, 10, .gray);

        if (current_gesture != .none) rl.drawCircleV(touch_position, 30, .maroon);
    }
}

fn gestureName(gesture: rl.Gesture) ?[:0]const u8 {
    return switch (gesture) {
        .tap => "GESTURE TAP",
        .doubletap => "GESTURE DOUBLETAP",
        .hold => "GESTURE HOLD",
        .drag => "GESTURE DRAG",
        .swipe_right => "GESTURE SWIPE RIGHT",
        .swipe_left => "GESTURE SWIPE LEFT",
        .swipe_up => "GESTURE SWIPE UP",
        .swipe_down => "GESTURE SWIPE DOWN",
        .pinch_in => "GESTURE PINCH IN",
        .pinch_out => "GESTURE PINCH OUT",
        else => null,
    };
}

/*******************************************************************************************
*
*   raylib [core] example - input gestures
*
*   Example complexity rating: [★★☆☆] 2/4
*
*   Example originally created with raylib 1.4, last time updated with raylib 4.2
*
*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
*   BSD-like license that allows static linking with closed source software
*
*   Copyright (c) 2016-2025 Ramon Santamaria (@raysan5)
*
********************************************************************************************/

#include "raylib.h"

#define MAX_GESTURE_STRINGS   20

//------------------------------------------------------------------------------------
// Program main entry point
//------------------------------------------------------------------------------------
int main(void)
{
    // Initialization
    //--------------------------------------------------------------------------------------
    const int screenWidth = 800;
    const int screenHeight = 450;

    InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures");

    Vector2 touchPosition = { 0, 0 };
    Rectangle touchArea = { 220, 10, screenWidth - 230.0f, screenHeight - 20.0f };

    int gesturesCount = 0;
    char gestureStrings[MAX_GESTURE_STRINGS][32];

    int currentGesture = GESTURE_NONE;
    int lastGesture = GESTURE_NONE;

    //SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected

    SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
    //--------------------------------------------------------------------------------------

    // Main game loop
    while (!WindowShouldClose())    // Detect window close button or ESC key
    {
        // Update
        //----------------------------------------------------------------------------------
        lastGesture = currentGesture;
        currentGesture = GetGestureDetected();
        touchPosition = GetTouchPosition(0);

        if (CheckCollisionPointRec(touchPosition, touchArea) && (currentGesture != GESTURE_NONE))
        {
            if (currentGesture != lastGesture)
            {
                // Store gesture string
                switch (currentGesture)
                {
                    case GESTURE_TAP: TextCopy(gestureStrings[gesturesCount], "GESTURE TAP"); break;
                    case GESTURE_DOUBLETAP: TextCopy(gestureStrings[gesturesCount], "GESTURE DOUBLETAP"); break;
                    case GESTURE_HOLD: TextCopy(gestureStrings[gesturesCount], "GESTURE HOLD"); break;
                    case GESTURE_DRAG: TextCopy(gestureStrings[gesturesCount], "GESTURE DRAG"); break;
                    case GESTURE_SWIPE_RIGHT: TextCopy(gestureStrings[gesturesCount], "GESTURE SWIPE RIGHT"); break;
                    case GESTURE_SWIPE_LEFT: TextCopy(gestureStrings[gesturesCount], "GESTURE SWIPE LEFT"); break;
                    case GESTURE_SWIPE_UP: TextCopy(gestureStrings[gesturesCount], "GESTURE SWIPE UP"); break;
                    case GESTURE_SWIPE_DOWN: TextCopy(gestureStrings[gesturesCount], "GESTURE SWIPE DOWN"); break;
                    case GESTURE_PINCH_IN: TextCopy(gestureStrings[gesturesCount], "GESTURE PINCH IN"); break;
                    case GESTURE_PINCH_OUT: TextCopy(gestureStrings[gesturesCount], "GESTURE PINCH OUT"); break;
                    default: break;
                }

                gesturesCount++;

                // Reset gestures strings
                if (gesturesCount >= MAX_GESTURE_STRINGS)
                {
                    for (int i = 0; i < MAX_GESTURE_STRINGS; i++) TextCopy(gestureStrings[i], "\0");

                    gesturesCount = 0;
                }
            }
        }
        //----------------------------------------------------------------------------------

        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();

            ClearBackground(RAYWHITE);

            DrawRectangleRec(touchArea, GRAY);
            DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, RAYWHITE);

            DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(GRAY, 0.5f));

            for (int i = 0; i < gesturesCount; i++)
            {
                if (i%2 == 0) DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.5f));
                else DrawRectangle(10, 30 + 20*i, 200, 20, Fade(LIGHTGRAY, 0.3f));

                if (i < gesturesCount - 1) DrawText(gestureStrings[i], 35, 36 + 20*i, 10, DARKGRAY);
                else DrawText(gestureStrings[i], 35, 36 + 20*i, 10, MAROON);
            }

            DrawRectangleLines(10, 29, 200, screenHeight - 50, GRAY);
            DrawText("DETECTED GESTURES", 50, 15, 10, GRAY);

            if (currentGesture != GESTURE_NONE) DrawCircleV(touchPosition, 30, MAROON);

        EndDrawing();
        //----------------------------------------------------------------------------------
    }

    // De-Initialization
    //--------------------------------------------------------------------------------------
    CloseWindow();        // Close window and OpenGL context
    //--------------------------------------------------------------------------------------

    return 0;
}

From raylib 6.2. The original on GitHub.