Всем привет! Меня зовут Григорий Дядиченко, и я разрабатываю разные проекты на заказ. Сегодня хотелось бы поговорить про рычаги и винты, и их реализацию в 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 - подписывайтесь на мой блог в телеграм. Я публикую там интересные новости и обзоры на них, свои мысли про бизнес, про фриланс и про разработку. В общем там много интересного. Спасибо за внимание!
