От винта! Рычаги и винты в Unity

Всем привет! Меня зовут Григорий Дядиченко, и я разрабатываю разные проекты на заказ. Сегодня хотелось бы поговорить про рычаги и винты, и их реализацию в Unity. Сейчас как раз на хайпе Apple Vision Pro, а подобные штуки бывают весьма полезны в проектах с виртуальной и дополненной реальностью. Если вы интересуетесь Unity разработкой и темой MR — добро пожаловать под кат! Может данная реализация пригодится в вашем проекте.

Почему тут важны MR проекты?

Давайте сначала немного определимся в терминах. MR (mixed reality) или смешанная реальность — это понятие по сути объединяющая понятия дополненной и виртуальной реальности. Данный термин несколько лет назад по сути начал популяризировать Microsoft.

Но причём тут рычаги и винты? Они в играх используются достаточно часто. Подойти и нажать запустить что-то по рычагу, покрутив винт можно во многих тайтлах вроде Half-Life или же Bioshock. Но чаще всего в игре они представляют из себя просто «логический объект». Это немного по-другому оформленные кнопки на которые можно нажать и произойдёт анимация вращения.

В MR так тоже конечно можно, но это может сбивать эффект погружения. Поэтому качественные AR и VR проекты чаще всего разрабатывать несколько дороже. Там требуется более «физичное» поведение объектов окружения. Тоже самое и с винтами. Классно когда за него можно взяться и физически покрутить.

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

Давайте сделаем такой рычаг и винт в Unity.

Сделаем наш рычаг

В чём заключается наша задача «Сделать рычаг»? По своей сути нам нужен объект в 3д пространстве за который мы можем взяться в определённой точке и с определённым ограничением движения изменить его положение в пространстве.

И для начала нам нужно определиться с системой координат. По сути тут их может быть три: мировая система координат, система координат рычага и система координат игрока.

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

И казалось бы с точки зрения Unity у нас есть доступ к мировой координате руки игрока и к мировой координате места, где мы берёмся за рычаг. Но не всё так просто. У мировой системы координат будет одна ключевая проблема — дальнейшая настройка рычагов в разных положениях в сцене.

С точки зрения разработки нам удобно сделать один рычаг и потом его клонировать по сцене. Он будет ограничен, с точки зрения объекта в пространстве двумя, основными параметрами: плоскость вращения и углы вращения. Рычаг же не должен ходить свободно в любую сторону, поэтому мы ограничиваем плоскость его движения. Для определения плоскости в трёхмерном пространстве нам достаточно двух параметров: точки на плоскости и нормали к этой плоскости. Если точкой на плоскости всегда является основание рычага, и там не имеет значения в какой оно системе координат. То вот с нормалью к плоскости в случае клонирования префаба по сцене работать в разы удобнее в локальной системе координат рычага. Потому что в противном случае нам нужно будет определять нормаль к плоскости вращения рычага в каждом созданном инстансе префаба.

Так что определим рычаг как его основание, плоскость вращения, начальное положение (или значение) и ограничения вращения. Я предпочитаю определять плоскость вращения енамом, так как тонкие настройки уже проще делать на уровне префаба. На мой взгляд есть две разумные плоскости вращения XY и ZY:

public enum Axis {     x,     z }

public class RotateObjectController : MonoBehaviour {     [SerializeField] private Transform _leverRoot;     [SerializeField] private Axis _localAxis;     [SerializeField] private float _startValue;     [SerializeField] private Vector2 _constraints;      private void Start()     {         _value =  Mathf.Clamp(_startValue, _constraints.x, _constraints.y);         _leverRoot.localRotation = Quaternion.Euler(GetAxis(_localAxis) * _value);     }      private void MoveLever(Vector3 worldPosition)     {         var localPosition = _leverRoot.parent.InverseTransformPoint(worldPosition);         var leverRootLocalPosition = _leverRoot.localPosition;         var localAxis = GetAxis(_localAxis);     }      private Vector3 GetAxis(Axis axis)     {         switch (axis)         {             case Axis.x:                 return new Vector3(1, 0, 0);             case Axis.z:                 return new Vector3(0, 0, 1);         }         return new Vector3();     } }

Заготовка готова. Осталось добавить немного математики. У нас есть основание рычага, есть точка в которую мы хотим подвинуть наш рычаг. Но нужно учитывать нюансы MR и тот факт, что это не рейкаст. Поэтому первоначально нам надо спроецировать точку которую мы получили для перемещения рычага в плоскость вращения рычага. Так как в Unity есть много встроенных удобных инструментов, то это делается в две строчки. Создаём плоскость и получаем проекцию точки на эту плоскость.

var plane = new Plane(localAxis, leverRootLocalPosition); var pos = plane.ClosestPointOnPlane(localPosition);

Дальше нам нужно рассчитать итоговое вращение, чтобы его применить. Для этого удобнее всего использовать функцию Quaternion.LookRotation. Данный метод возвращает кватернион определяющий поворот объекта в пространстве на основе двух векторов: forward и up. Итого у нас получилось:

public class RotateObjectController : MonoBehaviour {     [SerializeField] private Transform _leverRoot;     [SerializeField] private Axis _localAxis;     [SerializeField] private float _startValue;     [SerializeField] private Vector2 _constraints;      private void Start()     {         _value =  Mathf.Clamp(_startValue, _constraints.x, _constraints.y);         _leverRoot.localRotation = Quaternion.Euler(GetAxis(_localAxis) * _value);     }      private void MoveLever(Vector3 worldPosition)     {         var localPosition = _leverRoot.parent.InverseTransformPoint(worldPosition);         var leverRootLocalPosition = _leverRoot.localPosition;         var localAxis = GetAxis(_localAxis);         var plane = new Plane(localAxis, leverRootLocalPosition);         var pos = plane.ClosestPointOnPlane(localPosition);         _leverRoot.localRotation = Quaternion.LookRotation(                 localAxis,                 (pos - leverRootLocalPosition).normalized);     }      private Vector3 GetAxis(Axis axis)     {         switch (axis)         {             case Axis.x:                 return new Vector3(1, 0, 0);             case Axis.z:                 return new Vector3(0, 0, 1);         }         return new Vector3();     } }

Для анимаций или для управления чем-то, нам необходимо ещё получать значения вращения этого рычага. От значения вращения может зависеть насколько открыта какая-то дверь или в каком положении находится какой-то манипулятор. И тут есть важный момент.

Вращение в разы удобнее считать как дельту от прошлого вращения. В первую очередь это пригодится для реализации винта, так как винт может делать несколько оборотов вокруг своей оси. Следовательно нам нужно нормализованное значение общего вращения. Поэтому удобнее и проще работать с дельтой. Так как мы знаем нашу плоскость, то проще всего получить два вектора направления на этой плоскости и посчитать угол между ними со знаком. Таким образом мы получим нужную нам дельту через метод Vector3.SignedAngle:

public class RotateObjectController : MonoBehaviour {     [SerializeField] private Transform _leverRoot;     [SerializeField] private Axis _localAxis;     [SerializeField] private float _startValue;     [SerializeField] private Vector2 _constraints;      private Quaternion _lastRotation;     private float _value;      private void Start()     {         _value =  Mathf.Clamp(_startValue, _constraints.x, _constraints.y);         _leverRoot.localRotation = Quaternion.Euler(GetAxis(_localAxis) * _value);         _lastRotation = _leverRoot.localRotation;     }      private void MoveLever(Vector3 worldPosition)     {         var localPosition = _leverRoot.parent.InverseTransformPoint(worldPosition);         var leverRootLocalPosition = _leverRoot.localPosition;         var localAxis = GetAxis(_localAxis);         var plane = new Plane(localAxis, leverRootLocalPosition);         var pos = plane.ClosestPointOnPlane(localPosition);         _leverRoot.localRotation = Quaternion.LookRotation(                 localAxis,                 (pos - leverRootLocalPosition).normalized);         _value += CalculateValueDelta(_leverRoot.localRotation, localAxis);     }      private float CalculateValueDelta(Quaternion rotation, Vector3 axis)     {         return Vector3.SignedAngle(_lastRotation * Vector3.up, rotation * Vector3.up, axis);     }      private Vector3 GetAxis(Axis axis)     {         switch (axis)         {             case Axis.x:                 return new Vector3(1, 0, 0);             case Axis.z:                 return new Vector3(0, 0, 1);         }         return new Vector3();     } }

Сейчас мы можем вращать наш рычаг или винт, так как в своей сути это одно и тоже. Просто фигуры вращения. Но вращать его мы можем бесконечно. А для того, чтобы связать это всё с анимациями нам нужно применить наши ограничения. Так как тогда мы сможем получить нормализованное значение поворота нашего объекта вращения и работать с ним. Так что добавим логику ограничений.

Чтобы не было проблем выходы за границы наших ограничений, в которых у новичков часто происходит застревание объектов, нам нужно написать clamp для нашего значения поворота _value и уметь из него восстанавливать значение поворота рычага. Так как все данные для этого есть, то пишется это довольно просто:

private Quaternion ClampAngle(Quaternion rot, Vector3 axis) {     if (_value <= _constraints.x)     {         _value = _constraints.x;         return Quaternion.Euler(axis * _constraints.x);     }     if (_value >= _constraints.y)     {         _value = _constraints.y;         return Quaternion.Euler(axis * _constraints.y);     }      return rot; }

И итоговый удобный скрипт выглядит как:

public class RotateObjectController : MonoBehaviour {     [SerializeField] private Transform _leverRoot;     [SerializeField] private Axis _localAxis;     [SerializeField] private float _startValue;     [SerializeField] private Vector2 _constraints;      private Quaternion _lastRotation;     private float _value;      public float Value => _value;     public float NormalizedValue => (_value - _constraints.x) / (_constraints.y - _constraints.x);          private void Start()     {         _value =  Mathf.Clamp(_startValue, _constraints.x, _constraints.y);         _leverRoot.localRotation = Quaternion.Euler(GetAxis(_localAxis) * _value);         _lastRotation = _leverRoot.localRotation;     }      private void MoveLever(Vector3 worldPosition)     {         var localPosition = _leverRoot.parent.InverseTransformPoint(worldPosition);         var leverRootLocalPosition = _leverRoot.localPosition;         var localAxis = GetAxis(_localAxis);         var plane = new Plane(localAxis, leverRootLocalPosition);         var pos = plane.ClosestPointOnPlane(localPosition);         var rotation = Quaternion.LookRotation(                 localAxis,                 (pos - leverRootLocalPosition).normalized);         _value += CalculateValueDelta(rotation, localAxis);         _leverRoot.localRotation = ClampAngle(rotation, localAxis);         _lastRotation = _leverRoot.localRotation;     }      private Quaternion ClampAngle(Quaternion rot, Vector3 axis)     {         if (_value <= _constraints.x)         {             _value = _constraints.x;             return Quaternion.Euler(axis * _constraints.x);         }         if (_value >= _constraints.y)         {             _value = _constraints.y;             return Quaternion.Euler(axis * _constraints.y);         }              return rot;     }      private float CalculateValueDelta(Quaternion rotation, Vector3 axis)     {         return Vector3.SignedAngle(_lastRotation * Vector3.up, rotation * Vector3.up, axis);     }        private Vector3 GetAxis(Axis axis)     {         switch (axis)         {             case Axis.x:                 return new Vector3(1, 0, 0);             case Axis.z:                 return new Vector3(0, 0, 1);         }         return new Vector3();     } }

Но в VR тестировать всё не особо удобно, поэтому напишем ещё управление к данному рычагу с помощью мыши. Для этого введём интерфейс IWorldDraggable:

public interface IWorldDraggable {     void OnDrag(Vector3 worldPosition); }

И имплементируем его в наш скрипт:

using UnityEngine;  public class RotateObjectController : MonoBehaviour, IWorldDraggable {     [SerializeField] private Transform _leverRoot;     [SerializeField] private Axis _localAxis;     [SerializeField] private float _startValue;     [SerializeField] private Vector2 _constraints;      private Quaternion _lastRotation;     private float _value;      public float Value => _value;     public float NormalizedValue => (_value - _constraints.x) / (_constraints.y - _constraints.x);          private void Start()     {         _value =  Mathf.Clamp(_startValue, _constraints.x, _constraints.y);         _leverRoot.localRotation = Quaternion.Euler(GetAxis(_localAxis) * _value);         _lastRotation = _leverRoot.localRotation;     }      private void MoveLever(Vector3 worldPosition)     {         var localPosition = _leverRoot.parent.InverseTransformPoint(worldPosition);         var leverRootLocalPosition = _leverRoot.localPosition;         var localAxis = GetAxis(_localAxis);         var plane = new Plane(localAxis, leverRootLocalPosition);         var pos = plane.ClosestPointOnPlane(localPosition);         var rotation = Quaternion.LookRotation(                 localAxis,                 (pos - leverRootLocalPosition).normalized);         _value += CalculateValueDelta(rotation, localAxis);         _leverRoot.localRotation = ClampAngle(rotation, localAxis);         _lastRotation = _leverRoot.localRotation;     }      public void OnDrag(Vector3 worldPosition){       MoveLever(worldPosition);     }     private Quaternion ClampAngle(Quaternion rot, Vector3 axis)     {         if (_value <= _constraints.x)         {             _value = _constraints.x;             return Quaternion.Euler(axis * _constraints.x);         }         if (_value >= _constraints.y)         {             _value = _constraints.y;             return Quaternion.Euler(axis * _constraints.y);         }              return rot;     }      private float CalculateValueDelta(Quaternion rotation, Vector3 axis)     {         return Vector3.SignedAngle(_lastRotation * Vector3.up, rotation * Vector3.up, axis);     }        private Vector3 GetAxis(Axis axis)     {         switch (axis)         {             case Axis.x:                 return new Vector3(1, 0, 0);             case Axis.z:                 return new Vector3(0, 0, 1);         }         return new Vector3();     }

Удобнее всего на мой взгляд написать реализацию управления через EventSystem не забыв предварительно добавить его в сцену и PhysicsRaycaster на нашу камеру:

 [RequireComponent(typeof(IWorldDraggable))]   public class PointerWorldDragHandler : MonoBehaviour, IDragHandler   {       private IWorldDraggable _worldDraggable;       private void Awake()       {           _worldDraggable = GetComponent<IWorldDraggable>();       }        public void OnDrag(PointerEventData eventData)       {           if (eventData.pointerCurrentRaycast.gameObject == null) return;           _worldDraggable.OnDrag(eventData.pointerCurrentRaycast.worldPosition);       }   }

А управление в VR реализуется уже аналогичным образом в зависимости от используемого вами SDK.

В заключении

Вот мы и сделали наш рычаг или винт. С демо сценой и полным кодом проекта вы можете ознакомиться в репозитории. И возможно в каком-то проекте данная реализация под рукой будет вам полезна. Кстати, а почему не использовать джоинты и Unity физику. Зачем так сложно, ведь там готовы ограничения вращения и т.п. Короткий ответ опять-таки кроется в VR. С этим неудобно работать, потому что в VR при вращении у игрока нет тактильного отклика, и он не сможет держать руку на рычаге и реально вращать рычаг. Для удобства управления при зажатии курка мы «применяем руку игрока» к объекту, а потом уже графика руки крепится на рычаге, а положение реальной руки проецируется на плоскость вращения рычага. Пока игрок не отпустит курок джойстика.

Если вам интересны новости Unity разработки и в целом тема Unity — подписывайтесь на мой блог в телеграм. Я публикую там интересные новости и обзоры на них, свои мысли про бизнес, про фриланс и про разработку. В общем там много интересного. Спасибо за внимание!