Grundlagen-Tutorial zu Force-Feedback

Dieses Tutorial führt Sie durch die Erstellung einer einfachen haptischen Simulation, die sowohl Steifigkeit als auch Dämpfung berücksichtigt und die physikalischen Eigenschaften des Kontakts mit einem statischen Objekt, etwa einer Kugel, nachbildet. Am Ende dieses Tutorials haben Sie eine Simulation, mit der Sie das Vorhandensein einer Kugel spüren und deren Steifigkeits- und Dämpfungseigenschaften für verschiedene haptische Erlebnisse anpassen können.

Einführung

Die zentrale Herausforderung dieses Tutorials besteht darin, eine Funktion zu entwickeln, die die Kräfte berechnet, die beim Kontakt mit einer Kugel entstehen, die sowohl Steifigkeit als auch Dämpfung aufweist. Steifigkeit wirkt in diesem Zusammenhang wie eine Feder und erzeugt umso mehr Kraft, je stärker sie komprimiert wird. Dämpfung hingegen beschreibt den Widerstand eines Objekts gegen Bewegung: Je schneller es bewegt wird, desto größer ist dieser Widerstand.

Szenenaufbau

Beginnen Sie damit, ein Haptic Rig einzurichten, wie in der Anleitung „Erste Schritte“ beschrieben, und stellen Sie sicher, dass Position, Rotation und Skalierung des Haptic Origin auf (0, 0, 0) bzw. (1, 1, 1) gesetzt sind.

Erstellen Sie anschließend eine Kugel namens Sphere mit folgenden Eigenschaften:

• Position: (0, 0, -0.1) (etwa 10cm vor dem Gerät)
• Skalierung: (0.2, 0.2, 0.2) (entspricht einer Kugel mit 20cm Durchmesser)

Force-Feedback-Skript

Fügen Sie dem GameObject Sphere ein neues C#-Skript namens SphereForceFeedback.cs hinzu. Dieses Skript berechnet die Kräfte, die beim Kontakt mit der Kugel auf den Inverse3-Cursor wirken, und berücksichtigt dabei Steifigkeit und Dämpfung. Legen Sie für das Skript die folgenden Eigenschaften fest:

[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;

Die Kraftberechnung sollte nur dann erfolgen, wenn der Cursor die Kugel durchdringt, und so das Gefühl simulieren, ein physisches Objekt mit definierter Steifigkeit und Dämpfung zu berühren. Die Methode ForceCalculation ist dafür zuständig und berücksichtigt sowohl die Position als auch die Geschwindigkeit des Cursors:

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);
}

Initialisieren Sie in der Methode Awake _ballPosition, _ballRadius und _cursorRadius, um die Szenendaten einzurichten:

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

    _cursorRadius = inverse3.Cursor.Radius;
}

private void Awake()
{
    SaveSceneData();
}

Stellen Sie sicher, dass der Callback OnDeviceStateChanged in OnEnable registriert und in OnDisable wieder abgemeldet wird, um das Force-Feedback während der Interaktion korrekt zu verarbeiten:

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

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

Gameplay-Erlebnis

Während Sie den Inverse3-Cursor gedrückt halten, starten Sie den Play Mode und versuchen Sie, die Kugel zu berühren. Sie sollten die Präsenz der Kugel spüren und ihre Steifigkeits- und Dämpfungseigenschaften über den Unity-Inspector anpassen können. So entsteht ein greifbares Gefühl der Interaktion mit einem virtuellen Objekt.

Quelldateien

Die vollständige Szene und alle zugehörigen Dateien für dieses Beispiel können aus dem Beispiel Tutorials im Package Manager von Unity importiert werden.

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);
        }
    }
}