Haptic VR Gloves – Lutherie Numérique
For my VR Unity project, Seeds, in which the environment is made up of particles, I had the idea of designing haptic gloves. This project is carried out within the course Lutherie Numérique, at the UDEM. The particles are generated and controlled via the Vfx Graph of Unity’s new Scriptable Render Pipeline. The control and sensor part of the project is currently done using an Arduino Uno for prototyping, but I will switch for a smaller microcontroller later. A sensor on the gloves will also allow the movement of the particles to be synchronized with the user’s heartbeat. The main modules of the project are as follows:
| MODULE | SOLUTION | ÉTAT |
| Detect Hands Position | Leap Motion | Ready |
| Detect Heartbeat | Heartbeat sensor plugged in an Arduio | WIP |
| Read Sensor on the serial port (SlipOut) |
Temporary: PureData Finally: VVVV or Unity |
Ready (PureData) |
| Dialogue OSC with Unity |
PureData OSCjack (unity package) |
Ready |
| VfxGraph InOut : interaction with the particles |
In : Parameter binder Out : Gpu Event to Render Texture |
Ready |
| Send datas to serial (SlipIn) |
Temporary: PureData Finally: VVVV ou Unity |
WIP |
| Trig haptic feedback | Mini vibrating engines on gloves : one on each finger and one on each palm (12 in total) | WIP |
The main difficulty at the moment is to capture the collisions between the virtual fingers and the particles. The vfx graph is a GPU particle engine, so the scripts are fully executed on the graphics card. It’s not possible for now to get datas that are readable in the graph. This part is not scriptable either at the moment.
The current solution works quite well, but is not very optimized: In the VfxGraph (image opposite), the collision between the fingers and the particles can be detected. At each collision, the particle dies, and triggers a GPU event. This event generates a particle above the user so that he can’t see it. Each finger gives a different grayscale color to the particle. A camera is pointed at the particle and generates a low resolution (10px x 10px) rendering texture. Then, a script allows to retrieve the color of the texture center and to guess which finger touched a particle, which then allows to send the right OSC message to make the right finger vibrate.
For this part 2, the whole project is well presented in the video opposite. I am sorry that it is only in french. The modifications compared to part 1 are on the hardware interface, and towards Unity. The particle detection has not evolved since, the missing element was still not scriptable.
Pour mon projet en réalité virtuelle Seeds dans lequel l’environnement est constitué de particules, j’ai eu l’idée de concevoir des gants haptiques. Ce projet est réalisé dans le cadre du cours Lutherie Numérique, à l’UDEM. Les particules sont générées et contrôlées via le Vfx Graph du nouveau Scriptable Render Pipeline de Unity. La partie commande et capteurs du projet est pour l’instant réalisée à l’aide d’un Arduino Uno pour du prototypage, mais je passerais à un microcontrôleur plus petit par la suite. Un capteur sur les gants permettra également de synchronises le mouvement des particules avec les pulsations cardiaques de l’utilisateur. Les principaux modules du projets sont les suivants :
| MODULE | SOLUTION | STATE |
| Capter la position des mains | Leap Motion | Prêt |
| Capter les pulsations cardiaques | Capteur cardiaque branché au Arduino | WIP |
| Lire les données capteurs sur le port série (SlipOut) |
Temporaire : PureData Terme : VVVV ou Unity |
Prêt (PureData) |
| Dialogue OSC avec Unity |
PureData OSCjack (unity package) |
Prêt |
| VfxGraph InOut : interaction avec les particules |
In : Parameter binder Out : Gpu Event to Render Texture |
Prêt |
| Envoyer les données vers le port série (SlipIn) |
Temporaire : PureData Terme : VVVV ou Unity |
WIP |
| Déclencher des retours haptiques | Mini moteurs vibrants sur des gants : un sur chaque doigt et un sur chaque paume (12 au total) | WIP |
La principale difficulté pour l’instant est de capter les collisions entre les doigts virtuels et les particules. Le vfx graph est moteur de particules GPU, donc les scripts sont entièrement éxécutés sur la carte graphique. Il n’est pour l’instant pas possible de récupérer des données pourtant lisibles dans le graph. Cette partie n’est pas non plus scriptable pour le moment.
La solution actuelle fonctionne assez bien, mais n’est pas très optimisée : Dans le VfxGraph (image ci-contre), on peut détecter la collision entre les doigts et les particules. A chaque collision, la particule meurt, et déclenche un GPU event. Cet événement génère à son tour une particule au dessus de l’utilisateur afin qu’il ne puisse pas la voir. Chaque doigt donne une couleur en niveau de gris différente à la particule. Une caméra est dirigée sur la particule et génère une texture de rendu en basse définition (10px x 10px). Ensuite, un script permet de récupérer la couleur du centre de la texture et de deviner quel doigt a touché une particule, ce qui permet par la suite d’envoyer le bon message OSC pour faire vibrer le bon doigt.
Pour cette partie 2, l’ensemble du projet est bien présenté dans la vidéo ci-contre. Les modifications par rapport à la partie 1 sont sur l’interface matérielle, et vers Unity. la détéction des particules n’a pas évolué depuis, l’élément manquant n’était toujours pas scriptable.