Tutoriel de base sur le retour de force

Ce tutoriel vous guide dans la création d'une simulation haptique de base qui intègre à la fois la rigidité et l'amortissement, afin de simuler les propriétés physiques du contact avec un objet statique, comme une sphère. À la fin de ce tutoriel, vous disposerez d'une simulation qui vous permet de ressentir la présence d'une sphère et d'ajuster ses propriétés de rigidité et d'amortissement pour différentes expériences haptiques.

Introduction

Le défi principal de ce tutoriel consiste à développer une fonction capable de calculer les forces résultant du contact avec une sphère présentant à la fois une rigidité et un amortissement. Dans ce contexte, la rigidité agit comme un ressort : elle génère une force d'autant plus grande que l'objet est comprimé. L'amortissement, quant à lui, représente la résistance d'un objet au mouvement : il oppose une résistance d'autant plus grande que l'objet est déplacé rapidement.

Configuration de la scène

Commencez par configurer un Haptic Rig comme décrit dans le guide Premiers pas, en veillant à ce que la position, la rotation et l'échelle de Haptic Origin soient définies respectivement à (0, 0, 0) et (1, 1, 1).

Créez ensuite une sphère nommée Sphere avec les propriétés suivantes :

• Position : (0, 0, -0.1) (à environ 10 cm devant l'appareil)
• Échelle : (0.2, 0.2, 0.2) (correspondant à une sphère de 20 cm de diamètre)

Script de retour de force

Ajoutez un nouveau script C# au GameObject Sphere nommé SphereForceFeedback.cs. Ce script calculera les forces appliquées au curseur Inverse3 lors du contact avec la sphère, en tenant compte à la fois de la rigidité et de l'amortissement. Initialisez le script avec les propriétés suivantes :

[SerializeField]
private Inverse3 inverse3;

[Range(0, 800)]
public float stiffness = 300f;
[Range(0, 3)]
public float damping = 1f;

private Vector3 _ballPosition;
private float _ballRadius;
private float _cursorRadius;

Le calcul de la force ne doit se produire que lorsque le curseur pénètre la sphère, afin de simuler la sensation de toucher un objet physique doté d'une rigidité et d'un amortissement définis. La méthode ForceCalculation se chargera de cette tâche en tenant compte à la fois de la position et de la vitesse du curseur :

private Vector3 ForceCalculation(Vector3 cursorPosition, Vector3 cursorVelocity, float cursorRadius,
    Vector3 otherPosition, float otherRadius)
{
    var force = Vector3.zero;

    var distanceVector = cursorPosition - otherPosition;
    var distance = distanceVector.magnitude;
    var penetration = otherRadius + cursorRadius - distance;

    if (penetration > 0)
    {
        // Normalize the distance vector to get the direction of the force
        var normal = distanceVector.normalized;

        // Calculate the force based on penetration
        force = normal * penetration * stiffness;

        // Apply damping based on the cursor velocity
        force -= cursorVelocity * damping;
    }

    return force;
}

private void OnDeviceStateChanged(object sender, Inverse3EventArgs args)
{
    var inverse3 = args.DeviceController;
    // Calculate the ball force
    var force = ForceCalculation(inverse3.CursorLocalPosition, inverse3.CursorLocalVelocity,
        _cursorRadius, _ballPosition, _ballRadius);

    inverse3.SetCursorLocalForce(force);
}

Dans la méthode Awake, initialisez _ballPosition, _ballRadius et _cursorRadius pour configurer les données de la scène :

private void SaveSceneData()
{
    var t = transform;
    _ballPosition = t.position;
    _ballRadius = t.lossyScale.x / 2f;

    _cursorRadius = inverse3.Cursor.Radius;
}

private void Awake()
{
    SaveSceneData();
}

Veillez à enregistrer et à désenregistrer le rappel OnDeviceStateChanged dans les méthodes OnEnable et OnDisable, respectivement, afin de gérer correctement le retour de force pendant l'interaction :

protected void OnEnable()
{
    inverse3.DeviceStateChanged += OnDeviceStateChanged;
}

protected void OnDisable()
{
    inverse3.DeviceStateChanged -= OnDeviceStateChanged;
}

Expérience de jeu

En tenant le curseur Inverse3, passez en Play Mode et essayez de toucher la sphère. Vous devriez pouvoir ressentir la présence de la sphère et ajuster ses propriétés de rigidité et d'amortissement via l'Inspector de Unity, ce qui procure une sensation tangible d'interaction avec un objet virtuel.

Fichiers source

La scène complète et tous les fichiers associés à cet exemple peuvent être importés depuis l'exemple Tutorials du gestionnaire de paquets de Unity.

SphereForceFeedback.cs

/*
 * Copyright 2024 Haply Robotics Inc. All rights reserved.
 */

using Haply.Inverse.DeviceControllers;
using Haply.Inverse.DeviceData;
using UnityEngine;

namespace Haply.Samples.Tutorials._2_BasicForceFeedback
{
    public class SphereForceFeedback : MonoBehaviour
    {
        public Inverse3Controller inverse3;

        [Range(0, 800)]
        // Stiffness of the force feedback.
        public float stiffness = 300f;

        [Range(0, 3)]
        public float damping = 1f;

        private Vector3 _ballPosition;
        private float _ballRadius;
        private float _cursorRadius;

        /// <summary>
        /// Stores the cursor and sphere transform data for access by the haptic thread.
        /// </summary>
        private void SaveSceneData()
        {
            var t = transform;
            _ballPosition = t.position;
            _ballRadius = t.lossyScale.x / 2f;

            _cursorRadius = inverse3.Cursor.Radius;
        }

        /// <summary>
        /// Saves the initial scene data cache.
        /// </summary>
        private void Awake()
        {
            inverse3 ??= FindObjectOfType<Inverse3Controller>();
            inverse3.Ready.AddListener((device, args) => SaveSceneData());
        }

        /// <summary>
        /// Subscribes to the DeviceStateChanged event.
        /// </summary>
        private void OnEnable()
        {
            inverse3.DeviceStateChanged += OnDeviceStateChanged;
        }

        /// <summary>
        /// Unsubscribes from the DeviceStateChanged event.
        /// </summary>
        private void OnDisable()
        {
            inverse3.DeviceStateChanged -= OnDeviceStateChanged;
            inverse3.Release();
        }

        /// <summary>
        /// Calculates the force based on the cursor's position and another sphere position.
        /// </summary>
        /// <param name="cursorPosition">The position of the cursor.</param>
        /// <param name="cursorVelocity">The velocity of the cursor.</param>
        /// <param name="cursorRadius">The radius of the cursor.</param>
        /// <param name="otherPosition">The position of the other sphere (e.g., ball).</param>
        /// <param name="otherRadius">The radius of the other sphere.</param>
        /// <returns>The calculated force vector.</returns>
        private Vector3 ForceCalculation(Vector3 cursorPosition, Vector3 cursorVelocity, float cursorRadius,
            Vector3 otherPosition, float otherRadius)
        {
            var force = Vector3.zero;

            var distanceVector = cursorPosition - otherPosition;
            var distance = distanceVector.magnitude;
            var penetration = otherRadius + cursorRadius - distance;

            if (penetration > 0)
            {
                // Normalize the distance vector to get the direction of the force
                var normal = distanceVector.normalized;

                // Calculate the force based on penetration
                force = normal * penetration * stiffness;

                // Apply damping based on the cursor velocity
                force -= cursorVelocity * damping;
            }

            return force;
        }

        /// <summary>
        /// Event handler that calculates and send the force to the device when the cursor's position changes.
        /// </summary>
        /// <param name="sender">The Inverse3 data object.</param>
        /// <param name="args">The event arguments containing the device data.</param>
        private void OnDeviceStateChanged(object sender, Inverse3EventArgs args)
        {
            var inverse3 = args.DeviceController;
            // Calculate the ball force
            var force = ForceCalculation(inverse3.CursorLocalPosition, inverse3.CursorLocalVelocity,
                _cursorRadius, _ballPosition, _ballRadius);

            inverse3.SetCursorLocalForce(force);
        }
    }
}