Ein einfaches Tutorial zur Positionssteuerung

In diesem Tutorial wird auf der Grundlage der in der Einführungsanleitungvorgestellten Konzepte gezeigt, wie man mithilfe dynamischer Spielobjekte in einer Unity-Szene die Cursorposition eines „ Inverse3 “-Geräts steuern kann.

Einführung

Inverse3 Das Gerät unterstützt zwei Steuerungsmodi: **Kraftsteuerung (Force Control)** und **Positionssteuerung (Position Control)**. Im ersten Modus wird die Kraft entsprechend der Cursorposition angepasst, während im zweiten Modus die Cursorposition direkt gesteuert wird. Dieses Tutorial behandelt Tutorial zur Kraftrückmeldung in dynamischen SzenenUnter Verwendung der Szeneneinstellungen, FixedUpdate Innerhalb einer Methode CursorSetPositionDer Schwerpunkt liegt darauf, mithilfe von […] das Spielobjekt so zu konfigurieren, dass der Cursor des Geräts ihm folgt.

Szeneneinstellung

Tutorial zur Kraftrückmeldung in dynamischen SzenenEs beginnt mit der in … beschriebenen Szenenkonstruktion. Diese Konstruktion umfasst Haptisches Rigund MovableObject durch Komponenten gesteuert Bewegter Ball Es enthält Spielobjekte.

Implementierung der „SpherePositionControl“-Komponente

Bewegter Ball Spielobjekte SphereForceFeedback Komponente SpherePositionControl.csdurch ein neues C#-Skript mit dem Namen ersetzt. SpherePositionControl In der Klasse werden die folgenden Eigenschaften definiert:

public Inverse3 inverse3;
public float minSyncDistance = 0.05f;
private bool _isCursorSynchronized;

• inverse3: Dies ist ein Verweis auf die Gerätekomponente „ Inverse3 “, die über den Inspektor konfiguriert wird.
• minSyncDistance: Der Mindestabstand, ab dem die Cursor-Synchronisierung beginnt.
• _isCursorSynchronized: Ein Flag, das angibt, ob die Bewegung des Cursors mit „Moving Ball“synchronisiert ist.

Synchronisationslogik

Implementieren Sie eine Methode, die die Cursor-Synchronisation je nach Entfernung zum „Moving Ball“startet und stoppt:

private void StartSynchronizeCursor()
{
    var cursorPosition = inverse3.Cursor.transform.position;
    GetComponent<MovableObject>().SetTargetPosition(cursorPosition, teleport: true);
    _isCursorSynchronized = true;
}

private void StopSynchronizeCursor()
{
    _isCursorSynchronized = !inverse3.Release();
}

Hier wird MovableObject.SetTargetPosition(position, teleport:true)mit Hilfe von MovingBallund versetzt es sofort an die Cursorposition.

Die Methoden „Update“ und „FixedUpdate“

Update In der Methode werden der Cursor und Bewegter Ball Je nach Abstand zwischen den beiden Elementen wechselt der Cursor den Synchronisationsstatus:

private void Update()
{
    var distance = Vector3.Distance(inverse3.CursorPosition, transform.position);
    if (!_isCursorSynchronized && distance <= minSyncDistance)
    {
        StartSynchronizeCursor();
    }
    else if (_isCursorSynchronized && distance > minSyncDistance)
    {
        StopSynchronizeCursor();
    }
}

Wenn die Synchronisierung aktiviert ist, FixedUpdatean der Position des Cursors Bewegter BallAktualisieren Sie dies entsprechend der Position:

private void FixedUpdate()
{
    if (_isCursorSynchronized)
    {
        inverse3.SetCursorPosition(transform.position);
    }
}

Mit der `FixedUpdate`-Methode lässt sich sicherstellen, dass die Positionssteuerung unabhängig von der Grafik-Rendering-Leistung mit einer stabilen Bildwiederholrate läuft.

Zurücksetzen

Awake()Unabhängig von der Einstellung für die linke bzw. rechte Hand Bewegter BallStellen Sie sicher, dass dieses Gerät Inverse3 an einem Ort gestartet wird, auf den es zugreifen kann:

private void Awake()
{
    inverse3.Ready.AddListener(device =>
    {
        GetComponent<MovableObject>().SetTargetPosition(((Inverse3)device).WorkspaceCenterLocalPosition, teleport: true);
    });
}

Spielerlebnis

Inverse3 Befestigen Sie das Gerät und sorgen Sie für ausreichend Platz. Wenn Sie den „Play“-Modus aktivieren und den Cursor in die Nähe des „Moving Ball“bewegen, folgt das Gerät „ Inverse3 “ der Bewegung des „Moving Ball“. Sie können den „Moving Ball“über die Tastatur steuern und so überprüfen, ob der Cursor die Position korrekt nachverfolgt.

Quelldatei

Die gesamte Szene dieses Tutorials sowie die zugehörigen Dateien finden Sie im Unity-Paketmanager unter Anleitungen Sie finden es im Beispiel. Dieses Beispiel enthält MovableObject Es enthält ein Skript, das in verschiedenen Beispielen dazu dient, die Bewegung von Spielobjekten über Tastatureingaben zu steuern.

SpherePositionControl.cs

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

using Haply.Inverse.DeviceControllers;
using Haply.Samples.Tutorials.Utils;
using UnityEngine;

namespace Haply.Samples.Tutorials._5_SimplePositionControl
{
    /// <summary>
    /// Controls the Inverse3 cursor position based on the current position of this GameObject.
    /// When the GameObject is within a specified distance from the cursor, it initiates synchronized control,
    /// allowing the cursor to follow the GameObject's movements.
    /// </summary>
    [RequireComponent(typeof(MovableObject))]
    public class SpherePositionControl : MonoBehaviour
    {
        public Inverse3Controller inverse3;

        [Tooltip("Minimum distance required to initiate synchronized control between this GameObject and the Inverse3 cursor.")]
        [Range(0, 1)]
        public float minSyncDistance = 0.05f;

        private bool _isCursorSynchronized;

        private void Awake()
        {
            // Ensure inverse3 is set, finding it in the scene if necessary.
            inverse3 ??= FindFirstObjectByType<Inverse3Controller>();

            // When inverse3 is ready, so the handedness is defined
            inverse3.Ready.AddListener((device, args) =>
            {
                // Teleport the sphere to its workspace center to ensure it can be reached,
                // regardless of whether the device is left or right-handed. This ensures the GameObject starts in a
                // position that is accessible by the Inverse3 device.
                GetComponent<MovableObject>().SetTargetPosition(device.WorkspaceCenterLocalPosition, teleport:true);
            });
        }

        private void OnDisable()
        {
            // Ensure movement synchronization is disabled when the component is disabled.
            StopSynchronizeCursor();
            inverse3.Release();
        }

        private void Update()
        {
            if (!inverse3.IsReady)
            {
                return;
            }
            // Calculate the distance between the Inverse3 position and this object's position.
            var distance = Vector3.Distance(inverse3.CursorPosition, transform.position);

            // Enable synchronized movement if within the minimum sync distance and not already synced.
            if (!_isCursorSynchronized && distance <= minSyncDistance)
            {
                StartSynchronizeCursor();
            }
            // Disable synchronized movement if outside the minimum sync distance and currently synced.
            else if (_isCursorSynchronized && distance > minSyncDistance)
            {
                StopSynchronizeCursor();
            }
        }

        private void FixedUpdate()
        {
            if (_isCursorSynchronized)
            {
                // If in sync, set the Inverse3 cursor position to this object's position.
                inverse3.SetCursorPosition(transform.position);
            }
            else
            {
                inverse3.ProbeCursorPosition(true);
            }
        }

        private void StartSynchronizeCursor()
        {
            // Get the current cursor position.
            var cursorPosition = inverse3.Cursor.transform.position;

            // Teleport this object to the cursor position to avoid a sudden jump when position control starts.
            GetComponent<MovableObject>().SetTargetPosition(cursorPosition, teleport:true);

            // Start synchronizing the movement of this object with the cursor.
            _isCursorSynchronized = true;
        }

        private void StopSynchronizeCursor()
        {
            // Stop synchronizing the movement.
            _isCursorSynchronized = !inverse3.Release();
        }
    }
}