Как сделать сенсорное управление в unity

8

Mobile device input

On mobile devices, the Input class offers access to touchscreen, accelerometer and geographical/location input.

Access to keyboard on mobile devices is provided via the Mobile keyboard.

Multi-touch screen

The iPhone, iPad and iPod Touch devices are capable of tracking up to five fingers touching the screen simultaneously. You can retrieve the status of each finger touching the screen during the last frame by accessing the Input.touches property array.

Android devices don’t have a unified limit on how many fingers they track. Instead, it varies from device to device and can be anything from two-touch on older devices to five fingers on some newer devices.

Each finger touch is represented by an Input.Touch data structure:

Here’s an example script that shoots a ray whenever the user taps on the screen:

Mouse simulation

On top of native touch support Unity iOS/Android provides a mouse simulation. You can use mouse functionality from the standard Input class. Note that iOS/Android devices are designed to support multiple finger touch. Using the mouse functionality will support just a single finger touch. Also, finger touch on mobile devices can move from one area to another with no movement between them. Mouse simulation on mobile devices will provide movement, so is very different compared to touch input. The recommendation is to use the mouse simulation during early development but to use touch input as soon as possible.

Accelerometer

As the mobile device moves, a built-in accelerometer reports linear acceleration changes along the three primary axes in three-dimensional space. Acceleration along each axis is reported directly by the hardware as G-force values. A value of 1.0 represents a load of about +1g along a given axis while a value of –1.0 represents –1g. If you hold the device upright (with the home button at the bottom) in front of you, the X axis is positive along the right, the Y axis is positive directly up, and the Z axis is positive pointing toward you.

You can retrieve the accelerometer value by accessing the Input.acceleration property.

The following is an example script which will move an object using the accelerometer:

Low-Pass Filter

Accelerometer readings can be jerky and noisy. Applying low-pass filtering on the signal allows you to smooth it and get rid of high frequency noise.

The following script shows you how to apply low-pass filtering to accelerometer readings:

The greater the value of LowPassKernelWidthInSeconds , the slower the filtered value will converge towards the current input sample (and vice versa).

I’d like as much precision as possible when reading the accelerometer. What should I do?

Reading the Input.acceleration variable does not equal sampling the hardware. Put simply, Unity samples the hardware at a frequency of 60Hz and stores the result into the variable. In reality, things are a little bit more complicated – accelerometer sampling doesn’t occur at consistent time intervals, if under significant CPU loads. As a result, the system might report 2 samples during one frame, then 1 sample during the next frame.

You can access all measurements executed by accelerometer during the frame. The following code will illustrate a simple average of all the accelerometer events that were collected within the last frame:

Реализация последовательностей жестов в Unity 3D с помощью библиотеки TouchScript

Для начала необходимо настроить сцену. Для этого импортируем в Unity* 3D ресурс ландшафта в формате .fbx с горами и деревьями, экспортированный из Autodesk 3D Studio Max*. Поместим контроллер в центре ландшафта.
Установим показатель глубины основной камеры (она входит в состав контроллера) на уровень -1. Создадим отдельный элемент интерфейса камеры с поддержкой ортогональной проекции, шириной 1 и высотой 0,5, а также флагами Don’t Clear. Затем создадим слой GUIWidget и сделаем его маской интерфейса камеры.
Расположим основные элементы интерфейса, управляющие контроллером, на сцене в поле обзора ортогональной камеры. Добавим сферу для каждого пальца левой руки. Сфера мизинца заставляет контроллер двигаться влево, сфера безымянного пальца — вперед, среднего пальца — вправо, а указательного пальца — назад. Сфера большого пальца позволяет прыгать и запускать сферические снаряды под углом 30 градусов по часовой стрелке.
Для элемента интерфейса правой руки создадим куб (квадрат в ортогональной проекции). Настроим для этого куба поддержку жеста сдвига и привяжем его к скрипту MouseLook.cs. Этот элемент интерфейса обеспечивает такие же возможности, как и сенсорная панель устройства Ultrabook.
Эти элементы интерфейса расположим вне поля обзора основной камеры, а в качестве слоя установим GUIWidget. На рис. 1 можно увидеть, как элементы интерфейса позволяют запускать снаряды и управлять позицией контроллера на сцене.

Рисунок 1. Сцена контроллера от первого лица с ландшафтом и запущенными сферическими снарядами.

На этой сцене снаряды, запущенные из контроллера, пролетают сквозь деревья. Чтобы это исправить, необходимо добавить сетку или коллайдер к каждому дереву. Другая проблема на этой сцене — низкая скорость движения вперед — возникает при попытке посмотреть вниз с помощью сенсорной панели одновременно с движением вперед с помощью сферы безымянного пальца. Чтобы устранить эту неполадку, можно ограничить угол обзора при взгляде вниз, когда удерживается кнопка движения вперед.

Множественные касания

На базовой сцене находится контроллер от первого лица, который запускает снаряды под определенным углом по направлению от центра (см. Рисунок 1). По умолчанию установлен угол в 30 градусов по часовой стрелке.
Настроим сцену для поддержки множественных касаний, выполняемых чаще, чем установленный период, изменим угол запуска снарядов и попробуем запустить снаряд. В этом случае можно настроить угол на возрастание в геометрической прогрессии в зависимости от числа касаний при помощи переменных типа float в скрипте для сферы большого пальца слева. Эти переменные регулируют угол и время с момента запуска последнего снаряда:

Далее настроим цикл Update в скрипте для сферы большого пальца так, чтобы угол запуска снарядов снижался, если касания сферы большого пальца выполняются чаще, чем раз в полсекунды. В том случае, если касания последуют реже, чем раз в полсекунды, или угол запуска снарядов снизится до 0 градусов, величина угла запуска снарядов вернется к показателю 30 градусов. Получится следующий код:

Такой код произведет эффект обстрела, при котором непрерывные касания приведут к запуску снарядов под постоянно уменьшающимся углом (см. рис. 2). Этот эффект можно позволить настраивать пользователям либо сделать доступным при соблюдении определенных условий в игре или режиме симуляции.

Рисунок 2. Непрерывные касания приводят к изменению направления запуска снарядов

Масштабирование прокруткой

Мы настроили квадрат в правой нижней части экрана на рис. 1 на работу в режиме, аналогичном сенсорной панели на клавиатуре. При жесте сдвига квадрат не двигается, а поворачивает основную камеру сцены вверх, вниз, влево и вправо с помощью скрипта контроллера MouseLook. Аналогичным образом жест масштабирования (схожий со растягиванием/сжатием на других платформах) приводит не к масштабированию квадрата, а к изменению поля зрения основной камеры, благодаря которому пользователь может приблизить или отдалить объект на основной камере (см. Рисунок 3). Настроим контроллер таким образом, чтобы жест сдвига сразу после масштабирования возвращал поле зрения камеры к значению по умолчанию 60 градусов.
Для этого нужно запрограммировать логическую переменную (panned) и переменную типа float, чтобы они отмечали время, прошедшее от последнего жеста масштабирования:

Установим для переменной timeSinceScale значение 0.0f при выполнении жеста масштабирования, а для переменной panned — значение True при выполнении жеста сдвига. Поле зрения основной камеры сцены настраивается в цикле Update, как можно увидеть в скрипте для прямоугольника-сенсорной панели:

Рассмотрим функции onScale и onPan. Обратите внимание на то, что переменная float timeSincePan не позволяет полю зрения постоянно увеличиваться, когда для управления камерой используется сенсорная панель:

Рисунок 3. Основная камера сцены с изображением, приближенным при помощи прямоугольника сенсорной панели справа.

Нажатие, отпускание с щелчком

Если нажать и отпустить сферу мизинца, а затем в течение полусекунды провести по ней, можно увеличить горизонтальную скорость контроллера.
Для поддержки этой функции добавим переменную типа float и логическую переменную, которые позволят отмечать время с жестов отпускания сферы мизинца и жеста щелчка по ней:

При первоначальной установке сцены я предоставил скрипту сферы мизинца доступ к скрипту контроллера InputController, чтобы сфера мизинца слева могла заставлять контроллер двигаться влево. Переменная, управляющая горизонтальной скоростью контроллера, находится не в скрипте InputController, а в скрипте CharacterMotor. Передать скрипт сферы левого мизинца скрипту CharacterMotor можно аналогичным образом:

Функция onFlick в нашем скрипте лишь позволяет установить для логической переменной flicked значение, равное True.
Функция Update в скрипте вызывается один раз за кадр и изменяет движение контроллера по горизонтали следующим образом:

Благодаря этому коду можно увеличивать скорость движения по горизонтали. Для этого нужно нажать и отпустить сферу мизинца, а затем провести по ней в течение полсекунды. Настроить замедление движения по горизонтали можно различными способами. Например, для этого можно использовать нажатие и отпускание сферы указательного пальца, а затем щелчок по ней. Обратите внимание на то, что способ CHCharacterMotor.movement содержит не только параметр maxSidewaysSpeed, но также gravity, maxForwardsSpeed, maxBackwardsSpeed, и другие. Использование разнообразных жестов библиотеки TouchScript и объектов, которые обрабатывают жесты, в сочетании с этими параметрами обеспечивает широкие возможности и различные стратегии разработки сенсорных интерфейсов в сценах Unity 3D. При создании сенсорных интерфейсов для таких приложений можно пробовать различные варианты и выбирать наиболее эффективные и эргономичные.

Проблемы с последовательностями жестов

Последовательности жестов, которые мы использовали в этой статье, существенно зависят от функции Time.deltaTime. Я применяю эту функцию в сочетании с разными жестами до и после того, как функция определит действие. Две основные проблемы, с которыми я столкнулся при настройке этих случаев, заключаются в величине временного интервала и характере жестов.

Временной интервал

При написании этой статьи я использовал интервал в полсекунды. Если я выбирал интервал равный одной десятой секунды, устройство не могло распознать последовательности жестов. Хотя мне казалось, что темп касаний был достаточно высок, это не приводило к нужным действиям на экране. Возможно, это связано с задержками в работе устройства и ПО, поэтому рекомендую при разработке последовательностей жестов учитывать производительность целевой платформы.

Жесты

При работе над этим примером я изначально собирался использовать жесты масштабирования и сдвига, а затем касания и щелчка. Масштабирование и сдвиг работали правильно, но перестали, как только я добавил жест касания. Хотя мне удалось настроить последовательности из жестов масштабирования и сдвига, она не очень удобна для пользователя. Более удачным вариантом будет настроить другую цель касания в элементе интерфейса на обработку жестов касания и проведения после масштабирования и сдвига.
В этом примере я использую интервал времени в полсекунды, чтобы определять, выполнено действие или нет. Также можно настроить несколько временных интервалов, хотя это и приведет к усложнению интерфейса. Например, последовательность жестов нажатия и отпускания и следующего в течение полсекунды за ними проведения может увеличивать скорость движения по горизонтали, а аналогичная последовательность с интервалом от полсекунды до секунды — снижать скорость. Используя временные интервалы таким образом, можно не только более гибко настроить пользовательский интерфейс, но и добавить на сцену скрытые секреты.

Unity and touch controls

Pixelnest 14 mar. 2014

Welcome to a short Pixelnest’s tutorial. We will make a simple “game” where touching the screen will trigger some particles.

(Click to see the animation)

This is an advanced chapter. If you are new to Unity, we recommend you to follow our beginner’s tutorial first.

Warning: this tutorial has not been updated to Unity 5.

Disclaimer

We will cover the basics of touch controls on mobile devices.

Developing for a mobile platform requires you to have an appropriate device and the full SDK installed on your computer.

No wonder: deploying on iOS require you to have a Mac with Xcode.

Same for Android and Windows Phone: you need to have a working copy of the SDK.

If you are really new to mobile development, follow the official developer documentation and make an “Hello World” app to ensure that the SDK is properly working.

Here are the official places to find those resources:

Testing environments

Mobile deployment with Unity can be quite fastidious. It takes up to several minutes to fully deploy a project on a device.

This is because you cannot test directly on the device. You have to build, open the Xcode project (for iOS), compile then deploy.

iOS and Android

For iOS and Android, Unity comes with a small app: Unity Remote. It allows a device to connect to Unity via the local network.

Using the app, the touch screen becomes a usable interface with a degraded live preview of your computer.

This is the good way to debug touch controls, but you still need to fully deploy to really test the app on a device.

Note: the iOS app only works with a Mac.

Windows Phone

For Windows Phone there is no remote app but a closer integration with the Phone 8 SDK.

In the Windows Store Build Settings, select Phone 8.1 as the SDK value and check Unity C# projects .

This will allow you to build, deploy and debug directly from Visual Studio.

Setup

Let’s start! We will first define some prefabs and setup our project and then focus on the touch gestures.

Create a new 2D project. Then, follow the guide…

Explosion prefab

Import the following star texture (it’s white on blank, but it’s a star).

Set it as “Texture”.

Create an explosion prefab. Here is an idea:

A rainbow gradient:

You can tweak it as you like, it’s just a possibility.

Make sure to save it as a prefab.

Trail prefab

Create a new empty game object. Add a Trail Renderer component to it.

We will “rainbow” it too.

Create a new material with the Sprite/Default shader. Affect the material to the Trail Renderer .

Set some colors and tweak the size, like below:

(Move the object in the scene to preview the trail.)

Make sure to save it as a prefab.

“Vortex” prefab

If you like particles, try to reproduce this one:

It’s just a very slow effect that loops endlessly. The particles are nearly not moving with a high spawn rate.

Camera

Change the camera background to black. Set the Size to 10 .

Special effects helper script

This is a simple script that will handle everything related to the explosions and other effects creation.

Create a new SpecialEffectsScript and paste the code below:

Add the script to the scene. Fill it with our prefabs.

Enough preparation. It’s time to dig deeper in the real topic of this tutorial: touch controls!

Gestures

The main purpose of our little game/app/demo is to trigger effects (e.g., explosion or vortex like those we made previously) when the player is touching the screen.

Depending on the touch gesture (tap, swipe, pinch to zoom, etc.), we will trigger a particular effect. This way, we will be able to see if the right gesture is recognized as it should be.

Script

Create a new empty script GameScript :

Add the script to the scene.

Touch inputs

Let’s handle some common touch gestures.

A bit of documentation

The generic Input class centralizes all types of inputs information in one place, be it a keyboard, a joystick or touches.

The Input.touches is a collection of Touch and contains the available touches event and their state at a given frame.

A Touch is a finger information container that we will inspect when we need to handle touch controls.

The tap is a brief pressure from a finger. Like a click.

In the GameScript’s Update() method, add:

We look at every finger registered in the Input class and if a finger has just been moved off the screen, we make an explosion where it was.

This would work with less code, but this way we make sure it’s not another sort of gesture (which comes next).

Note: touch.position is a screen location and not a world one. That’s why we must use Camera.main.ScreenToWorldPoint to get the location in the world coordinates.

Let’s make a trail when the user touches the screen and drags his finger across it.

First, add a new member that will contain the association between a finger and a trail:

Then, inside Update() , add this code in the for loop:

A bit verbose but quite simple:

1. If the touch is a new one, we create a new trail and associate it to the finger via the dictionary.
2. When the finger moves, if we have a trail associated to it, we also move the trail’s game object.
3. When the finger is released, we destroy the trail.

Pinch

A pinch is the typical zoom/unzoom gesture. Two fingers getting closer or further.

We need some new variables to store the first position of the fingers. This way, we can compute the actual distance difference.

We also store the vortex effect (remember the Prefab we created before) played by the gesture to be able to update and delete it.

Add this to the Update() method, outside the for loop this time:

Yes, the pinch is slightly more complicated, mainly because we don’t want it do be taken for anything else.

If two fingers are on the screen, we create a new vortex between the two positions. Then, we declare that the gesture is a pinch. Finally, if the fingers move, we also move and scale the vortex object.

Eventually, and as soon as one finger is missing, the vortex is turned into some explosions. The gesture is over.

_{Note from Matthieu: Michael Bay would be proud.}

Full script

Testing & deployment

To test on a device, see our deployment chapter in our previous tutorial.

Contact and feedback

If you find a typo, a mistake or a misspelling, let us know on our twitter. You can also contact us by mail.

If you want further informations about a specific topic, or a clarification on this tutorial, we would be happy to hear you too.

Finally, you can follow us on twitter if you like what we do. 🙂

This tutorial was redacted by Damien, and edited by Matthieu. We hope you will enjoy it.

© 2016 Pixelnest Studio — we craft games and apps

Работа с Touch в Unity3D

Ни для кого не секрет, что в мобильных играх, в отличие от компьютерных, практически единственным “устройством ввода” является палец. То есть, все действия, которые пользователь выполняет в игре, совершаются благодаря прикосновениям к экрану, или же тачам (англ. touch – прикосновение). В этой статье мы с Вами рассмотрим, как можно правильно обработать тачи, разберем, в чем разница между глобальными и локальными тачами, а также реализуем обработку некоторых популярных жестов, которыми Вы оперируете не только в играх, но и в повседневном пользовании смартфоном – swipe и zoom. Разумеется, все это мы будем делать, используя исключительно встроенный функционал Unity3D, без внешних плагинов и ассетов.

Наведем справки

Перед тем, как начать, рассмотрим, какие возможности нам предоставляет библиотека для работы с тачами. В документации Unity видим, что разработчики движка рекомендуют использовать класс Input для получения доступа к данным об акселерометре и мульти-таче мобильного устройства. Это нас вполне устраивает.

В обязательном порядке необходимо подключить пространство имен UnityEngine.EventSystems, ведь именно оттуда родом большинство интерфейсов и классов, которые нам сегодня понадобятся. Например, IPointerClickHandler , IDragHandler и многие другие. В конце концов, классы BaseEventData и PointerEventData , из которых мы будем доставать все необходимые данные о событиях, проживают по тому же адресу.

Что ж, не стоит волноваться, если Вы видите эти имена впервые. Моя задача — сдружить вас и наставить на путь плодотворной разработки.

Если у Вас уже имеется опыт работы с данными классами, надеюсь, смогу поведать о каких-либо интересных спецификах работы с ними и еще некоторыми компонентами.

Ближе к делу или “Что такое глобальные и локальные тачи?”

Немного теории.

Чтобы правильно реализовать все, что мы задумали, сначала разберемся, что такое глобальные и локальные тачи. Если вкратце, то глобальные тачи – это прикосновения к экрану устройства в любой точке. То есть, мы будем говорить, что необходимо обработать глобальный тач, если для игрового процесса не важно, где именно игрок ткнет пальцем в экран. Думаю, все видели в играх заставку после загрузки уровня с большими буквами “Tap to start” либо что-то в этом роде. Бывают настолько простые игры, что, по сути, все управление игроком производится исключительно такими вот глобальными тачами. Например, в Flappy Bird, 2 Cars и многих других.

Разумеется, не всегда все так просто. Случается, нам необходимо обработать тач в определенной области экрана, или по какой-либо кнопке, или по объекту. Такие тачи мы с Вами будет именовать локальными, так как они должны производиться в некой локальной области. Причем принципы реализации обработки тачей по 2D объектам или же элементам UI и обработки тачей по 3D объектам на сцене немного отличаются. Эти нюансы мы также рассмотрим.

То есть перед тем, как перейти к воплощению идеи в жизнь, хорошенько подумайте, где и какой вид тача будет использоваться, ведь от этого зависит, как далеко в лес мы пойдем и как много дровишек нарубим.

Практика.

Подготовим рабочее место, как на картинке. Также создадим новый скрипт HandleScript и прикрепим его на куб.

Как же считать прикосновение к экрану? Если в случае с кликами мыши в классе Input есть методы GetMouseButton (. Up, . Down), то для тачей соответствующие методы отсутствуют. Здесь все даже проще. Разработчики предоставляют свойство touchCount (только для чтения), в котором хранится количество тачей в текущем кадре. То есть, чтобы считать глобальный тач, нам необходима всего одна строчка в методе Update:

public class HandleScript : MonoBehaviour

if ( Input .touchCount > 0) Debug .Log( "Global touch!" );

Как только пользователь задумает ткнуть пальцем в экран (чего мы, по сути, и ждем), выражение в блоке условия вернет true и на консоль вылетит наше сообщение. Что может быть проще?

Важно: проверить данный способ обработки на компьютере не получится, так как в свойство touchCount записывается именно кол-во тачей. Клики мыши не в счет.

Примечание: К примеру, при портировании на Windows Phone сообщения консоли, разумеется, отображаться не будут. Так что стоит реакцию на тач сделать более явной. Допустим:

if ( Input .touchCount > 0) transform.localScale *= 1.1f;

Я специально буду обращать Ваше внимание на многие нюансы (для кого-то известные и очевидные, а для кого-то — нет), чтобы избавить от мелких и неприятных ошибок и сберечь парочку нервных клеток.

Попробуйте сбилдить на свой смартфон и немного потапать в разных частях экрана.

Что касается локальных тачей, то здесь есть несколько вариантов обработки. Также они зависят и от типа объекта – 2 D или 3 D .

Тема связана со специальностями:

Начнем, пожалуй, с 2 D объектов. Давайте добавим на сцену какой-либо спрайт и сразу прилепим ему компонент 2 D Box Collider (о нем чуть ниже).

Еще добавим к этому спрайту наш скрипт HandleScript , но немного его подкорректируем. В Unity есть перечень методов, которые являются обработчиками определенных событий. Например, метод OnCollisionEnter вызывается, когда два твердых ( Rigidbody ) объекта соприкасаются, если вкратце. Так вот, среди вышеупомянутого перечня методов есть такой себе OnMouseDown метод. Он вызывается, как вы уже, наверное, догадались, в момент нажатия левой кнопки мыши непосредственно на объекте.

• Метод вызывается непосредственно в момент нажатия кнопки, а не отпускания или полного клика.
• Метод реагирует только на левую кнопку мыши.
• Срабатывает только при клике непосредственно на объект.

Так как мы с Вами обрабатываем тачи, а не клики, то справедливы для нас будут только первый и третий пункты. То есть работу с человеческими пальцами данный метод тоже поддерживает. А может, и не только человеческими.

Как же будет выглядеть наш код?

public class HandleScript : MonoBehaviour

transform . localScale *= 1.1 f ;

Обратите внимание на сигнатуру метода и запомните. Ведь если сделать малейшую опечатку, событие касания/клика обрабатываться не будет. Проверить работу этого способа уже проще. Учитывая, что метод OnMouseDown реагирует как на мышь, так и на пальцы, билдить проект на смартфон не обязательно. Из этой серии есть еще метод OnMouseUp , который вызывается при отпускании пальца/кнопки.

Важно : все события, связанные с кликами, движок Unity считывает, неявно используя Raycast ’ы (лучи). Именно поэтому мы добавили на наш спрайт компонент 2 D Box Collider . Если Вы еще не знаете, в чем суть работы Raycast ’ов, обязательно почитайте в документации Unity .

Важно : получается, указанные методы срабатывают при тапе/клике именно по коллайдеру объекта, а не по мэшу( Mesh )/спрайту.

Попробуйте сбилдить и потапать на спрайт ящика либо зеленого куба.

Теперь отключите их коллайдеры и проверьте, обрабатывается ли событие. Как видите, этот способ позволяет обработать тап как по 2 D , так и по 3 D объекту. Просто?

Следующий способ обработать локальн ый тач тоже работает для обоих типов объектов, но немного отличается конфигурацией компонентов. Здесь мы с Вами будем уже работать с таким пространством имен, как UnityEngine . EventSystems . Если оно у Вас еще не подключено, самое время это сделать. Там, как я уже говорил, находятся необходимые нам интерфейсы и классы. Теперь обязательно добавьте на сцену объект EventSystem . Он находится во вкладке UI контекстного меню создания объекта.

Итак, чтобы считать тап по 2 D объекту (не элементу UI ), необходимо обязательно прикрепить к камере компонент Physics 2 D Raycaster . Для данного компонента обязательным является присутствие компонента Camera . Поэтому совсем неудивительно, что мы цепляем его именно на объект Main Camera .

То есть после всех наших манипуляций игровая сцена должна выглядеть, как на картинке.

Теперь, пожалуй, в код. Данный метод более универсальный, чем предыдущий, так как позволяет получить множество информации о состоянии курсора. Неважно, кто им управляет – палец или мышь.

Нам понадобится интерфейс IPointerDownHandler из подключенного пространства имен. После реализации единственного его метода, получаем код, не менее простой, чем раньше.

public class HandleScript : MonoBehaviour , IPointerDownHandler

public void OnPointerDown( PointerEventData eventData)

Debug . Log ( eventData . position );

Разумеется, ошибиться с сигнатурой метода у вас не выйдет, так как Visual Studio сразу ругнется за нереализованный интерфейс. А в параметре eventData типа PointerEventData будет храниться вся информация о курсоре на момент срабатывания метода, а это очень полезно.

Что же будет происходить? Здесь тоже все просто. В момент касания движок Unity пустит луч в сцену и в случае, когда тот пройдет сквозь коллайдер нашего спрайта, сработает метод обработчик OnPointerDown и в параметр eventData запишется вся информация о курсоре. Для считывания тачей также есть следующие интерфейсы:

IPointerUpHandler , IPointerClickHandler , IPointerEnterHandler и IPointerExitHandler .

Мне кажется, по их именам предельно ясно, какой из них какое событие позволяет обработать. Все, что Вам необходимо – наследоваться от нужного интерфейса, реализовать единственный его абстрактный метод и удивиться, как просто это работает. Главное, когда будете работать, не забудьте о компоненте Physics 2 D Raycaster и объекте EventSystem , которые упоминались выше.

Как вы уже, наверное, заметили, на 3D объекты данный способ не распространяется. Как это исправить? Элементарно. На объект-камеру необходимо также прикрепить компонент Physics Raycaser . Вот и все. Остальная суть остается та же.

Попробуйте запустить проект. Заметили? Движок реагирует на клики мыши тоже. Теперь портируйте на ваш смартфон и удостоверьтесь, что все работает верно.

Чтобы обработать тачи по элементам UI, Вам необходим будет компонент Graphic Raycaster . Но для него обязательным является компонент Canvas . Это, думаю, тоже вполне логично. Если прикрепить его на объект Canvas , то методы рассмотренных нами интерфейсов позволят также обработать тачи по кнопкам, панелям, тогглам и т.д.

Итог по разделу о глобальных и локальных тачах.

Давайте немного подсуммируем все, что только что было рассмотрено.

Видео курсы по схожей тематике:

Unity Стартовый 2015

Синхронизация данных двух информационных систем с использованием LINQ и Entity FW 6

• Все тачи и клики обрабатываются неявным пусканием лучей из экрана в сцену. То есть определяется касание к коллайдерам объектов.
• При использовании интерфейсов из пространства имен UnityEngine.EventSystems обязательно надо добавить объект EventSystem .
• Physics2DRaycaster – компонент для обработки тачей/кликов по 2 D объектам.
• PhysicsRaycaster – компонент для обработки тачей/кликов по 3 D объектам.
• GraphicRaycaster – компонент для обработки тачей/кликов по элементам UI . В отличие от предыдущих присутствует на объекте Canvas по умолчанию.

Обработка Swipe жестов

Как же выловить эти Swipe жесты и как определить их направление? На самом деле, это совсем несложно. Есть несколько интерфейсов, которые позволят нам это сделать:

IDragHandler , IBeginDragHandler , IEndDragHandler .

Причем, они отлично подходят как для работы с Drag , так и Swipe жестами. Давайте почистим нашу сцену и приведем ее примерно вот к такому виду:

У нас на объекте Canvas есть красная панель размером на весь экран и внутри нее имеется еще одна небольшая панель. Мы с Вами будем считывать Swipe ’ы по красной панели и в зависимости от их направления двигать зеленую. Все до безобразия просто. Аналогичные действия Вы потом сможете проделать не только с элементами UI , как в этом примере, но и с 2 D и 3 D объектами. Сейчас же будем использовать панели, так как это получится более наглядно.

Скрипт HandlerScript прикрепляем к внешней (красной) панели.

public class HandleScript : MonoBehaviour , IDragHandler , IBeginDragHandler

public void OnBeginDrag( PointerEventData eventData)

public void OnDrag( PointerEventData eventData)

Вот как изначально должен выглядеть наш скрипт. Мы должны наследоваться он интерфейсов IDragHandler и IBeginDragHandler . Этого будет достаточно, чтобы считать Swipe . Скажу даже больше. Мы будем использовать только метод из второго интерфейса.

Важно : необходимо обязательно реализовать интерфейс IDragHandler (пусть даже методом с пустым телом), чтоб ы срабатывали методы из интерфейсов IBeginDragHandler и IEndDragHandler .

Дабы определить направление Swipe ’а, мы будет использовать свойство delta в параметре eventData метода OnBeginDrag . В это свойство записывается разница позиций курсора между текущим и предыдущим кадрами. Мы просто напросто в момент начала Swipe ’а глянем, какое значение этой дельты, и из этого уже определим, какое направление жеста.

Возможно, у Вас возник вопрос. Откуда возьмется эта дельта, если метод OnBeginDrag сработает сразу, как только игрок начнет вести пальцем по экрану? Дело вот в чем. Этот метод вызывается только после того, как игрок сдвинет палец на какое-то пороговое значение расстояния от начальной точки. За это время успевает накопиться некоторая информация о происшедшем событии. То есть за этот небольшой промежуток времени мы можем определить, куда пользователь собирается вести свой палец.

Мы всего лишь должны построить правильную условную конструкцию для определения направления и, исходя из условия, двигать зеленую панель в соответствующем направлении. В будущем это может быть ваш игрок в раннере или что-либо иное.

public class HandleScript : MonoBehaviour , IDragHandler , IBeginDragHandler

Transform green ; // здесь будет ссылка на компонент Transform зеленой панели.

green = transform . GetChild (0); // получаем ссылку на Transform зеленой панели.

public void OnBeginDrag( PointerEventData eventData)

if ( Mathf .Abs(eventData.delta.x) > Mathf .Abs(eventData.delta.y))

if (eventData.delta.x > 0) Debug .Log( "Right" );

green.position += new Vector3 (eventData.delta.x, 0, 0);

if (eventData.delta.y > 0) Debug .Log( "Up" );

green.position += new Vector3 (0, eventData.delta.y, 0);

public void OnDrag( PointerEventData eventData)

Что мы сделали? Сначала проверили, дельта по какой оси больше – X или Y ? Если по оси X , значит движение будет по горизонтали, если же по Y – значит, по вертикали. А там еще раз проверили направление. Как видите, это делается элементарно просто, а работает безотказно. Обязательно проверьте, обрабатывается ли жест Swipe у вас на смартфоне.

Если же Вам необходимо получить непосредственно угол Swipe ’а, можно использовать формулу , которая позволяет вычислить синус угла прямоугольного треугольника из отношения противоположной и прилегающей сторон.

Обработка Zoom’а

Вернем сцену к первоначальному состоянию. Чтобы считать жест zoom ’ а, нам необходимо обработать глобальн ые тачи, поэтому наш скрипт HandleScript можно прикрепить даже на камеру.

А код наш будет выглядеть вот так:

public class HandleScript : MonoBehaviour

public float sensitivity;

if ( Input .touchCount < 2)

f0start = Vector2 .zero;

f1start = Vector2 .zero;

if ( Input .touchCount == 2) Zoom();

if (f0start == Vector2 .zero && f1start == Vector2 .zero)

f0start = Input .GetTouch(0).position;

f1start = Input .GetTouch(1).position;

Vector2 f0position = Input .GetTouch(0).position;

Vector2 f1position = Input .GetTouch(1).position;

float dir = Mathf .Sign( Vector2 .Distance(f1start, f0start) — Vector2 .Distance(f0position, f1position));

transform.position = Vector3 .MoveTowards(transform.position, transform.position + transform.forward, dir * sensitivity * Time .deltaTime * Vector3 .Distance(f0position, f1position));

Бесплатные вебинары по схожей тематике:

Новая система ввода в Unity.

Как стать Java разработчиком.

Как за час создать игру на Unity3D.

В чем суть его работы? Если пользователь прикасается к экрану двумя пальцами, координаты двух тачей записываются в соответствующие поля f 0 start и f 1 start . Именно с ними будут сравниваться все остальные позиции тачей, пока игрок не уберет от экрана пальцы. То есть мы просто сравниваем расстояние между двумя тачами. Если текущее расстояние меньше, чем начальное, то камера будет двигаться назад, если же больше – вперед.

Условная конструкция в методе Zoom для того, чтобы позиции тачей записались в свойства только один раз в момент касания к экрану.

Чувствительность zoom ’а вы можете регулировать значением поля sensitivity прямо в окне Inspector . Попробуйте усовершенствовать этот скрипт сами. Допустим, сделать, чтобы сравнивались позиции не текущих и начальных тачей, а позиции тачей в этом и предыдущем кадре. Сравните результат.

Заключение

Как видите, обработка тачей и рассмотренных нами жестов реализуется очень просто. Все, что Вам необходимо – внимательность и фантазия. Если что-то не работает, обязательно проверьте, присутствуют ли необходимые компоненты на всех объектах, вызываются ли нужные методы и так далее.

Совсем не обязательно искать внешние библиотеки, плагины и ассеты для того, чтобы работать с тачами в Unity . Разработчики предоставляют, по сути, всё, что вам может понадобится. Результат же зависит от Вашей фантазии.

Не забывайте заглядывать в документацию Unity , там есть много всего интересного. Хотя, среди того, что мы сегодня рассмотрели, есть вещи, о которых там не упоминают.