Tutoriel sur les forces fondamentales et la position

Ce guide explique brièvement comment appliquer une force et visualiser le mouvement du curseur Inverse3 . Une fois cette opération effectuée,Inverse3 simulera l'impression d'être attaché à sa position de départ par un élastique virtuel, tandis qu'un GameObject sphérique indiquera la position du curseur.

Présentation

Le guide d'introduction présente Inverse3 les objets, leurs fonctionnalités ainsi que les méthodes permettant de générer une force constante. L'objectif de cette section est de simuler l'effet d'un élastique sur le curseur. Le comportement d'un élastique est similaire à celui d'un ressort, c'est-à-dire que la force qu'il exerce dépend à la fois de sa rigidité et de la distance entre ses deux extrémités. Nous allons donc concevoir une fonction qui, à partir d'une position et d'une rigidité données, génère une force permettant au curseur de résister à un mouvement s'éloignant de l'origine.

Mise en scène

Commencez par créer un « Haptic Rig (one hand) »via le menu GameObjects > Haply.

Composant ForceAndPosition

Sélectionner Origine haptique GameObject, ajoutez un élément nommé ForceAndPosition.cs un nouveau script, et dans ForceAndPosition Insérez le code suivant dans la classe :

[SerializeField]
private Inverse3 inverse3 = null;

[SerializeField, Range(0, 400)]
private float stiffness = 100;

private void OnDeviceStateChanged(object sender, Inverse3EventArgs args)
{
    var inverse3 = args.DeviceController;

    // Calculate the force.
    var force = (inverse3.WorkspaceCenterLocalPosition - inverse3.CursorLocalPosition) * stiffness;

    // Apply the force to the cursor.
    inverse3.SetCursorLocalForce(force);
}

Ce paragraphe définit la rigidité à 100 newtons par mètre (N/m) afin de simuler un ressort relativement souple. Il introduit également inverse3.WorkspaceCenterLocalPosition, cette propriété renvoie le centre de l'espace de travail. Cette méthode calcule la force en soustrayant la position du curseur du centre de l'espace de travail, puis multiplie le résultat par la rigidité. Enfin, on utilise inverse3.SetCursorLocalForce Appliquer cette force au curseur.

conformément à Guide de démarrage Explications détaillées dans le OnEnable et OnDisable Ajouter dans la méthode OnDeviceStateChanged Rappel :

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

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

Mécaniques de jeu

Placez le curseur sur Inverse3 , passez en mode lecture, puis essayez de manipuler l'appareil. Vous constaterez que le déplacement du curseur génère une force. Plus le curseur s'éloigne de sa position initiale, plus cette force est perceptible.

Fichier source

Le scénario final utilisé dans cet exemple, ainsi que tous les fichiers associés, peuvent être importés à partir de la section « Tutorials » du gestionnaire de paquets de Unity.

ForceAndPosition.cs

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

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

namespace Haply.Samples.Tutorials._1_ForceAndPosition
{
    /// <summary>
    /// Demonstrates the application of force to maintain the cursor at its center position.
    /// </summary>
    public class ForceAndPosition : MonoBehaviour
    {
        public Inverse3Controller inverse3;

        [Range(0, 400)]
        // Stiffness of the force feedback.
        public float stiffness = 100;

        private void Awake()
        {
            inverse3 ??= FindObjectOfType<Inverse3Controller>();
        }

        /// <summary>
        /// Subscribes to the DeviceStateChanged event when the component is enabled.
        /// </summary>
        protected void OnEnable()
        {
            inverse3.DeviceStateChanged += OnDeviceStateChanged;
        }

        /// <summary>
        /// Unsubscribes from the DeviceStateChanged event and reset the force when the component is disabled.
        /// </summary>
        protected void OnDisable()
        {
            inverse3.DeviceStateChanged -= OnDeviceStateChanged;
            inverse3.Release();
        }

        /// <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 force.
            var force = (inverse3.WorkspaceCenterLocalPosition - inverse3.CursorLocalPosition) * stiffness;

            // Apply the force to the cursor.
            inverse3.SetCursorLocalForce(force);
        }
    }
}