Diese Seite wurde automatisch übersetzt und kann Fehler enthalten. Original auf Englisch ansehen

Class UBhapticsSDK2

Erbt von UBlueprintFunctionLibrary

Die Klasse UBhapticsSDK2 enthält die Funktionen zur Nutzung der Haptik-Geräte von bHaptics.

Referenzen


Module	BhapticsPlugin
Header	Engine\Plugins\Marketplace\BhapticsPlugin\Source\BhapticsPlugin\Public\BhapticsSDK2.h
Include	#include "BhapticsSDK2.h"

Statische Funktionen — Event-gesteuerte Haptik abspielen

Spielt die Haptik-Pattern ab, die an ein bestimmtes, in Designer/Portal erstelltes Haptik-Event gebunden sind. Wir empfehlen dringend, diese Funktionen zu verwenden.

PlayHaptic

static int PlayHaptic(FString eventId);

Spielt das Haptik-Event ab. Es ist die grundlegendste Methode, ein Haptik-Event aufzurufen. Es hat den geringsten Overhead aller Funktionen zum Aufrufen von Haptik-Events.

Parameters

FString eventId: Name des Haptik-Events, das Sie abspielen möchten.

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
    // Assuming the event name is "shootpistol"
    UBhapticsSDK2::PlayHaptic("shootpistol");
}

PlayHapticWithOption

static int PlayHapticWithOption(FString eventId, float intensity = 1.0f, float duration = 1.0f, float angleX = 0.0f, float offsetY = 0.0f);

Spielt ein Haptik-Event ab und passt dabei Stärke, Duration und Richtung der Haptik an.

Parameters

FString eventId: Name des Haptik-Events, das Sie abspielen möchten.
float intensity: Die haptische Intensity wird mit diesem Wert multipliziert.
float duration: Die haptische Duration wird mit diesem Wert multipliziert.
float angleX: Dreht die Haptik gegen den Uhrzeigersinn um die globale Vector3.up. Gültiger Bereich: [0.0f - 360.0f]
float offsetY: Bewegt die Haptik nach oben oder unten. Gültiger Bereich: [-0.5f - 0.5f]

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
    UBhapticsSDK2::PlayHapticWithOption(
        "shootpistol", //  Haptic name
        1.0f, // Haptic intensity
        1.0f, // Haptic duration
        0.0f, // Rotate haptic around global Vector3.up (0f - 360f)
        0.0f  // Move haptic up or down (-0.5f - 0.5f)
    );
}

PlayWithStartTime

static int PlayWithStartTime(FString eventId, int startMillis = 0, float intensity = 1.0f, float duration = 1.0f, float angleX = 0.0f, float offsetY = 0.0f);

Spielt ein Haptik-Event ab und passt dabei Stärke, Duration und Richtung der Haptik an.

Parameters

FString eventId: Name des Haptik-Events, das Sie abspielen möchten.
int startMillis: Startposition der Wiedergabe in Millisekunden. Die ersten startMillis Millisekunden des Events werden übersprungen (dies ist ein Start-Offset, keine Verzögerung vor der Wiedergabe). Der Standardwert ist 0. Nur Windows/macOS/Android.
float intensity: Die haptische Intensity wird mit diesem Wert multipliziert.
float duration: Die haptische Duration wird mit diesem Wert multipliziert.
float angleX: Dreht die Haptik gegen den Uhrzeigersinn um die globale Vector3.up. Gültiger Bereich: [0.0f - 360.0f]
float offsetY: Bewegt die Haptik nach oben oder unten. Gültiger Bereich: [-0.5f - 0.5f]

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
    UBhapticsSDK2::PlayWithStartTime(
        "shootpistol", //  Haptic name
        0,    // Playback start position (millisecond)
        1.0f, // Haptic intensity
        1.0f, // Haptic duration
        0.0f, // Rotate haptic around global Vector3.up (0f - 360f)
        0.0f  // Move haptic up or down (-0.5f - 0.5f)
    );
}

PlayLoop

static int PlayLoop(FString eventId, float intensity = 1.0f, float duration = 1.0f, float angleX = 0.0f, float offsetY = 0.0f, int interval = 200, int maxCount = 999999);

Spielt die Haptik wiederholt ab. Zusätzlich können Sie, wie bei der Funktion PlayHapticWithOption, Stärke, Duration und Richtung der Haptik anpassen.

Parameters

FString eventId: Name des Haptik-Events, das Sie abspielen möchten.
float intensity: Die haptische Intensity wird mit diesem Wert multipliziert.
float duration: Die haptische Duration wird mit diesem Wert multipliziert.
float angleX: Dreht die Haptik gegen den Uhrzeigersinn um die globale Vector3.up. Gültiger Bereich: [0.0f - 360.0f]
float offsetY: Bewegt die Haptik nach oben oder unten. Gültiger Bereich: [-0.5f - 0.5f]
int interval: Das Zeitintervall zwischen den Wiederholungen, gemessen in Millisekunden.
int maxCount: Die Anzahl der Wiederholungen.

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
    UBhapticsSDK2::PlayLoop(
        "shootpistol",  // Haptic name
        1.0f,  // Haptic intensity
        1.0f,  // Haptic duration
        0.0f,  // Rotate haptic around global Vector3.up (0f - 360f)
        0.0f,  // Move haptic up or down (-0.5f - 0.5f)
        200,   // Loop interval time (millisecond)
        999999 // Loop count
    );
}

Statische Funktionen — Haptik direkt abspielen

Wenn Sie Haptik abspielen möchten, ohne ein neues Event zu erstellen, verwenden Sie diese Funktionen.

PlayDot

static int PlayDot(int position, TArray<int> motorValues, float seconds = 0.5f);

Spielt haptisches Feedback am angegebenen Haptik-Aktuator ab. Sie können diese Funktion verwenden, ohne ein Event zu erstellen.

Parameters

int position: Typ des Haptik-Geräts. Weitere Informationen finden Sie hier.

Wert	Gerät	Entspricht…	Motoranzahl
`0`	TactSuit Pro	`EBhapticsDevicePosition::Vest`	32
`1`	TactSleeve(Left)	`EBhapticsDevicePosition::ForearmL`	3
`2`	TactSleeve(Right)	`EBhapticsDevicePosition::ForearmR`	3
`3`	TactVisor	`EBhapticsDevicePosition::Head`	4
`4`	Tactosy for Hands(Left)	`EBhapticsDevicePosition::HandL`	3
`5`	Tactosy for Hands(Right)	`EBhapticsDevicePosition::HandR`	3
`6`	Tactosy for Feet(Left)	`EBhapticsDevicePosition::FootL`	3
`7`	Tactosy for Feet(Right)	`EBhapticsDevicePosition::FootR`	3
`8`	TactGlove(Left)	`EBhapticsDevicePosition::GloveL`	8
`9`	TactGlove(Right)	`EBhapticsDevicePosition::GloveR`	8

TArray<int> motorValues: Legen Sie die Länge des Arrays entsprechend der Anzahl der Motoren des Geräts fest. Die Werte im Array bezeichnen die Intensity der Motoren. Gültiger Bereich für jeden Wert im Array: [0 - 100]
float seconds: Die Duration der Haptik, gemessen in Sekunden. Ein Wert größer oder gleich 0.1f wird empfohlen.

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
 // TactSuit Pro has 32 motors, so length of array should be 32 too.
    TArray<int> MotorValueArray = TArray<int>{
        50, 40, 30, 20, 10, 50, 40, 30,
        50, 40, 30, 20, 10, 50, 40, 30,
        50, 40, 30, 20, 10, 50, 40, 30,
        50, 40, 30, 20, 10, 50, 40, 30};

    UBhapticsSDK2::PlayDot(
        (int)EBhapticsDevicePosition::Vest, // Device type
        MotorValueArray,                    // Haptic intensities
        0.5f                                // Haptic duration (second)
    );
}

PlayPath

static int PlayPath(int position, TArray<float> x, TArray<float> y, TArray<int> motorValues, float seconds = 0.5);

Spielt Haptik um bestimmte Koordinaten herum ab. Anders als die Funktion PlayDot, die die haptische Intensity für jeden Haptik-Aktuator einzeln angibt, gibt diese Methode die haptische Intensity für bestimmte Koordinaten an.

Bei der Angabe der Haptik-Position bietet PlayDot eine diskrete Steuerung, während PlayPath kontinuierlicher ist. PlayDot weist einzelnen Aktuatoren Intensity zu, während PlayPath Intensity für bestimmte Koordinaten zuweist (zwischen 0 und 1 für die X- und Y-Achse), wodurch nahegelegene Aktuatoren entsprechend vibrieren.

Sie können mehrere Koordinaten mit mehreren Intensities in das Array eintragen. Beachten Sie, dass alle Aktuatoren um diese Koordinaten im Array herum gleichzeitig (zur selben Zeit) aktiviert werden, nicht nacheinander. Außerdem muss die Größe aller Arrays gleich sein.

Indem Sie diese Funktion fortlaufend aufrufen und dabei die Werte schrittweise ändern, können Sie den Effekt eines sich bewegenden Haptik-Punkts erzielen.

[TactGlove DK3] PlayPath steuert den Handgelenk-Voice-Coil-Motor (VCM) eines DK3-Gloves nicht an.

Frame 82.png

Parameters

int position: Typ des Haptik-Geräts.

Wert	Gerät	Entspricht…
`0`	TactSuit Pro	`EBhapticsDevicePosition::Vest`
`1`	TactSleeve(Left)	`EBhapticsDevicePosition::ForearmL`
`2`	TactSleeve(Right)	`EBhapticsDevicePosition::ForearmR`
`3`	TactVisor	`EBhapticsDevicePosition::Head`
`4`	Tactosy for Hands(Left)	`EBhapticsDevicePosition::HandL`
`5`	Tactosy for Hands(Right)	`EBhapticsDevicePosition::HandR`
`6`	Tactosy for Feet(Left)	`EBhapticsDevicePosition::FootL`
`7`	Tactosy for Feet(Right)	`EBhapticsDevicePosition::FootR`
`8`	TactGlove(Left)	`EBhapticsDevicePosition::GloveL`
`9`	TactGlove(Right)	`EBhapticsDevicePosition::GloveR`

TArray<float> x: Legt die X-Koordinate fest. Gültiger Bereich für jeden Wert im Array: [0.0f - 1.0f]
TArray<float> y: Legt die Y-Koordinate fest. Gültiger Bereich für jeden Wert im Array: [0.0f - 1.0f]
TArray<int> motorValues: Legen Sie die Länge des Arrays entsprechend der Anzahl der Koordinaten fest. Die Werte im Array bezeichnen die Intensity der Koordinaten. Gültiger Bereich für jeden Wert im Array: [0 - 100]
float seconds: Die Duration der Haptik, gemessen in Sekunden. Ein Wert größer oder gleich 0.1f wird empfohlen.

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

/* Assumption:
 - For TactSuit Pro
 - Coordinate with Intensity
    - (X: 0.1, Y: 0.2) Intensity 40
    - (X: 0.3, Y: 0.4) Intensity 80
    - (X: 0.5, Y: 0.6) Intensity 10
  - Duration 0.5 second
*/
void AExample::Shoot()
{
    UBhapticsSDK2::PlayPath(
        (int)EBhapticsDevicePosition::Vest, // Device Type
        TArray<float>{0.1f, 0.3f, 0.5f},    // X Coordinates
        TArray<float>{0.2f, 0.4f, 0.6f},    // Y Coordinates
        TArray<int>{40, 80, 10},            // Intensities
        0.5f                                // Duration
    );
}

PlayWaveform

static int PlayWaveform(int position, TArray<int> motorIntensities, TArray<EBhapticsGlovePlayTime> playTimeValues, TArray<EBhapticsGloveShapeValue> shapeValues, int frequency = 80, int repeatCount = 0);

Nur TactGlove. Spielt Haptik im TactGlove ab. Anders als bei PlayDot können Sie die haptische Duration und die Änderungen der Vibrations-Intensity fein anpassen. Dies ermöglicht eine noch feinere Darstellung von haptischem Feedback.

Jedes Array (motorIntensities, playTimeValues, shapeValues) muss sechs Elemente für TactGlove DK2 oder acht Elemente für TactGlove DK3 enthalten, und alle drei Arrays müssen dieselbe Länge haben. Jede andere Länge gibt -1 zurück.

Parameters

int position: Typ des Haptik-Geräts.

Wert Gerät Entspricht…
8 TactGlove(Left) EBhapticsDevicePosition::GloveL
9 TactGlove(Right) EBhapticsDevicePosition::GloveR

Wert	Gerät	Entspricht…
`8`	TactGlove(Left)	`EBhapticsDevicePosition::GloveL`
`9`	TactGlove(Right)	`EBhapticsDevicePosition::GloveR`

TArray<int> motorIntensities: Ein Array, das die Intensity jedes Motors darstellt. Seine Länge muss der Anzahl der Motoren im TactGlove entsprechen: sechs (TactGlove DK2) oder acht (TactGlove DK3). Die Handflächen-Motoren an den Array-Indizes 6 und 7 (in der Tabelle unten) existieren nur auf DK3. Gültiger Bereich für jeden Wert im Array: [0 - 100]

Array Index	Motor befindet sich an…
`0`	Spitze des Daumens
`1`	Spitze des Zeigefingers
`2`	Spitze des Mittelfingers
`3`	Spitze des Ringfingers
`4`	Spitze des kleinen Fingers
`5`	Am Handgelenk
`6`	An der Handfläche (Daumenseite)
`7`	An der Handfläche (Kleinfingerseite)

TArray<EBhapticsGlovePlayTime> playTimeValues: Ein Array mit derselben Länge wie motorIntensities (sechs für DK2, acht für DK3), wobei jedes Element ein Zeitintervall für die Aktuierung darstellt, wobei die Zeit über EBhapticsGlovePlayTime-Enums definiert wird.

Wert	Duration	Entspricht…
`EBhapticsGlovePlayTime::None`	Keine	`0`
`EBhapticsGlovePlayTime::FiveMS`	5ms	`1`
`EBhapticsGlovePlayTime::TenMS`	10ms	`2`
`EBhapticsGlovePlayTime::TwentyMS`	20ms	`4`
`EBhapticsGlovePlayTime::ThirtyMS`	30ms	`6`
`EBhapticsGlovePlayTime::FortyMS`	40ms	`8`

TArray<EBhapticsGloveShapeValue> shapeValues: Ein Array mit derselben Länge wie motorIntensities (sechs für DK2, acht für DK3), wobei jedes Element die Form der zeitlichen Änderung der haptischen Intensity darstellt, angegeben durch die EBhapticsGloveShapeValue-Enums.

Wert	Waveform	Entspricht…
`EBhapticsGloveShapeValue::Constant`	Konstante Intensity für die Duration	`0`
`EBhapticsGloveShapeValue::Decreasing`	Beginnt bei der angegebenen Intensity und nimmt um die Hälfte ab	`1`
`EBhapticsGloveShapeValue::Increasing`	Beginnt bei der Hälfte der angegebenen Intensity und steigt bis zur angegebenen an.	`2`

[TactGlove DK3] Auf dem DK3-Glove ist der Handgelenk-Aktuator (Array-Index 5) ein Voice-Coil-Motor (VCM) und berücksichtigt shapeValues nicht. Die anderen sieben Motoren wenden die Waveform-Form genauso an wie auf DK2-Gloves.

int frequency: [Nur TactGlove DK3] Vibrationsfrequenz in Hz der eigenen Aktuatoren des DK3-Gloves. Der Standardwert ist 80. Dies betrifft nur das DK3-Glove selbst und ändert nicht die Betriebsfrequenz anderer verbundener Geräte. Es hat keine Auswirkung auf DK2-Gloves oder auf den universellen (Nicht-Windows/macOS-)Pfad. Nur Windows/macOS.
int repeatCount: Anzahl der Wiederholungen der Waveform, ab 1. 0 spielt sie einmal ab. Nur Windows/macOS.

Returns

Request ID. Sie können die Request ID verwenden, um die Haptik zu stoppen. Bei einem Fehlschlag wird -1 zurückgegeben.

Bei Verbindung mit dem Hub geben fehlgeschlagene Aufrufe jedoch kein -1 zurück, da der Hub keinen Rückgabewert bereitstellt.

Example

#include "BhapticsSDK2.h"

void AExample::Shoot()
{
    TArray<int> GloveMotorValue = TArray<int>{50, 50, 50, 50, 50, 50, 50, 50};

    TArray<EBhapticsGlovePlayTime> GlovePlayTime = {
        EBhapticsGlovePlayTime::FiveMS, EBhapticsGlovePlayTime::TenMS,
        EBhapticsGlovePlayTime::TwentyMS, EBhapticsGlovePlayTime::ThirtyMS,
        EBhapticsGlovePlayTime::FortyMS, EBhapticsGlovePlayTime::None,
        EBhapticsGlovePlayTime::None, EBhapticsGlovePlayTime::None};

    TArray<EBhapticsGloveShapeValue> GloveShapeValue = {
        EBhapticsGloveShapeValue::Constant, EBhapticsGloveShapeValue::Decreasing,
        EBhapticsGloveShapeValue::Increasing, EBhapticsGloveShapeValue::Constant,
        EBhapticsGloveShapeValue::Decreasing, EBhapticsGloveShapeValue::Increasing,
        EBhapticsGloveShapeValue::Constant, EBhapticsGloveShapeValue::Constant};

    UBhapticsSDK2::PlayWaveform(
        (int)EBhapticsDevicePosition::GloveL, // Device Type
        GloveMotorValue,                      // Intensities
        GlovePlayTime,                        // Intervals
        GloveShapeValue                       // Intensity changing forms
    );
}

Statische Funktionen — Sonstige

StopHapticByEventId

static bool StopHapticByEventId(FString eventId);

Stoppt das Haptik-Event anhand der Event ID. Gibt zurück, ob das Stoppen erfolgreich war.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    UBhapticsSDK2::StopHapticByEventId("eventID");
}

StopHapticByRequestId

static bool StopHapticByRequestId(int requestId);

Stoppt das Haptik-Event anhand der Request ID, die von der Funktion zurückgegeben wird, die die Haptik ausführt. Gibt zurück, ob das Stoppen erfolgreich war.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    int RequestID = UBhapticsSDK2::PlayHaptic("eventID");
    UBhapticsSDK2::StopHapticByRequestId(RequestID);
}

StopHaptic

static bool StopHaptic();

Stoppt alle aktuell abgespielten Haptiken. Gibt zurück, ob das Stoppen erfolgreich war.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    UBhapticsSDK2::PlayHaptic("bangbang");
    UBhapticsSDK2::PlayHaptic("eventID");
    UBhapticsSDK2::PlayHaptic("explosion");

    UBhapticsSDK2::StopHaptic();
}

PauseHapticByEventId

static void PauseHapticByEventId(FString eventId);

Pausiert das Haptik-Event anhand der Event ID. Die Wiedergabeposition wird beibehalten, sodass es später mit ResumeHapticByEventId fortgesetzt werden kann.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    UBhapticsSDK2::PauseHapticByEventId("eventID");
}

ResumeHapticByEventId

static void ResumeHapticByEventId(FString eventId);

Setzt ein zuvor mit PauseHapticByEventId pausiertes Haptik-Event fort und fährt an der Position fort, an der es pausiert wurde.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    UBhapticsSDK2::ResumeHapticByEventId("eventID");
}

IsPlaying

static bool IsPlaying();

Prüft, ob die Haptik abgespielt wird.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    if (UBhapticsSDK2::IsPlaying())
    {
        StopHaptic();
    }
}

IsPlayingByEventId

static bool IsPlayingByEventId(FString eventId);

Prüft, ob das Haptik-Event für diese Event ID abgespielt wird.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    UBhapticsSDK2::PlayHaptic("eventID");

    if (UBhapticsSDK2::IsPlayingByEventId("eventID"))
    {
        UBhapticsSDK2::StopHapticByEventId("eventID");
    }
}

IsPlayingByRequestId

static bool IsPlayingByRequestId(int requestId);

Prüft, ob das Haptik-Event für diese Request ID abgespielt wird.

#include "BhapticsSDK2.h"

void AExample::Example()
{
    int RequestID = UBhapticsSDK2::PlayHaptic("eventID");
    if (UBhapticsSDK2::IsPlayingByRequestId(RequestID))
    {
        UBhapticsSDK2::StopHapticByRequestId(RequestID);
    }
}

Initialize

static void Initialize();

Initialisiert die Haptik-Umgebung. Diese Funktion sollte vor der Nutzung der haptikbezogenen Funktionen aufgerufen werden.

Ping

static void Ping(FBhapticsDevice device);

Sendet einfaches haptisches Feedback an ein bestimmtes Gerät.

PingAll

static void PingAll();

Sendet einfaches haptisches Feedback an alle verbundenen Geräte.

Destroy

static void Destroy();

Gibt die Haptik-Umgebung frei. Diese Funktion muss beim Beenden des Spiels aufgerufen werden und darf NUR EINMAL aufgerufen werden.

GetBhapticsDevices

static TArray<FBhapticsDevice> GetBhapticsDevices();

Ruft ein Array mit Informationen über die verbundenen Haptik-Geräte ab.

IsBhapticsAvailable

static bool IsBhapticsAvailable();

Prüft, ob die Haptik-Umgebung initialisiert und bereit zur Nutzung der haptikbezogenen Funktionen ist.

ProjectToVest

static FBhapticsRotationOption ProjectToVest(
    FVector ContactLocation,
    UPrimitiveComponent* PlayerComponent,
    float HalfHeight = 0
);

Hilfsfunktion zur Berechnung der Offset-Werte (Winkel und Höhe) eines gegebenen Kollisions-Kontaktpunkts relativ zum Spieler. Diese Offset-Werte können in PlayHapticWithOption und PlayLoop verwendet werden, die die Haptik-Position anpassen können.

Diese Funktion geht davon aus, dass die Vorwärtsrichtung mit der Vorderseite der Vest übereinstimmt, und betrachtet die Position des Spielers als Ursprung.

Sehen Sie sich für detaillierte Informationen das Beispiel unten an.

Parameters

FVector ContactLocation: Kontaktpunkt in globalen Koordinaten.
UPrimitiveComponent* PlayerComponent: Referenz auf die am Spieler angehängte Primitive-Komponente.
float HalfHeight: Der halbe Wert der tatsächlichen Körpergröße des Spielers, gemessen in Zentimetern.

Example

Nehmen wir an, dass eine Haptik implementiert wird, wenn man in einem VR-Spiel angeschossen wird. Das entsprechende Haptik-Pattern für dieses Event wäre ein kurzes und starkes haptisches Feedback in der vorderen Mitte des TactSuit. Um den Realismus zu erhöhen, wäre es ideal, die Höhe und den Winkel des haptischen Feedbacks danach zu variieren, wo der Spieler getroffen wird.

Die Funktionen PlayHapticWithOption und PlayLoop erlauben das Anpassen der Höhe und des Winkels des Haptik-Patterns. Diese Funktionen nehmen Werte für Winkel (OffsetAngleX) und Höhe (OffsetY) zur Haptik-Anpassung entgegen.

Die Funktion ProjectToVest berechnet die Winkel- und Höhenwerte basierend darauf, wo der Spieler getroffen wird, den Transform-Informationen des Spielers und der Körpergröße des Benutzers. Diese Werte werden dann in der Struktur FBhapticsRotationOption gekapselt und zurückgegeben.

Frame 81 (1).png

#include "BhapticsSDK2.h"

void AExample::HitByBullet()
{
    APawn *PlayerPawn = UGameplayStatics::GetPlayerPawn(GetWorld(), 0);
    UPrimitiveComponent *PlayerComponent = Cast<UPrimitiveComponent>(PlayerPawn->GetRootComponent());

    FVector ContactLocation = USomewhere::GetContactLocationSomehow();
    float HalfHeight = YourActualHeight / 2;

    FBhapticsRotationOption result = UBhapticsSDK2::ProjectToVest(ContactLocation, PlayerComponent, HalfHeight);

    UBhapticsSDK2::PlayHapticWithOption("hit_by_bullet", 1.0f, 1.0f, result.OffsetAngleX, result.OffsetY);
}

ProjectToVestLocation

static FBhapticsRotationOption ProjectToVestLocation(FVector ContactLocation, FVector PlayerLocation, FRotator PlayerRotation);

Hilfsfunktion zur Berechnung von Offset-Werten aus einer Kontaktposition und den Transform-Informationen des Spielers. Sie ähnelt ProjectToVest, berechnet aber nur den Winkel-Offset (OffsetAngleX). Die Höhe (OffsetY) ist immer 0.

Parameters

FVector ContactLocation: Kontaktpunkt in globalen Koordinaten.
FVector PlayerLocation: Position des Spielers.
FRotator PlayerRotation: Rotation des Spielers.

CustomProjectToVest

static FBhapticsRotationOption CustomProjectToVest(FVector ContactLocation, UPrimitiveComponent* PlayerComponent, float HalfHeight = 0, FVector UpVector = FVector::ZeroVector, FVector ForwardVector = FVector::ZeroVector);

Hilfsfunktion zur Berechnung von Offset-Werten aus einer Kollision. Erfüllt dieselbe Funktion wie ProjectToVest, erlaubt aber, die Forward- und Up-Vektoren zu ändern.

FVector ContactLocation: Kontaktpunkt in globalen Koordinaten.
UPrimitiveComponent* PlayerComponent: Referenz auf die am Spieler angehängte Primitive-Komponente.
float HalfHeight: Der halbe Wert der tatsächlichen Körpergröße des Spielers, gemessen in Zentimetern.
FVector UpVector: Der als Referenz dienende Aufwärtsrichtungsvektor für die Offset-Berechnung.
FVector ForwardVector: Der als Referenz dienende Vorwärtsrichtungsvektor für die Offset-Berechnung.

Referenzen​

Statische Funktionen — Event-gesteuerte Haptik abspielen​

PlayHaptic​

Parameters​

Returns​

Example​

PlayHapticWithOption​

Parameters​

Returns​

Example​

PlayWithStartTime​

Parameters​

Returns​

Example​

PlayLoop​

Parameters​

Returns​

Example​

Statische Funktionen — Haptik direkt abspielen​

PlayDot​

Parameters​

Returns​

Example​

PlayPath​

Parameters​

Returns​

Example​

PlayWaveform​

Parameters​

Returns​

Example​

Statische Funktionen — Sonstige​

StopHapticByEventId​

StopHapticByRequestId​

StopHaptic​

PauseHapticByEventId​

ResumeHapticByEventId​

IsPlaying​

IsPlayingByEventId​

IsPlayingByRequestId​

Initialize​

Ping​

PingAll​

Destroy​

GetBhapticsDevices​

IsBhapticsAvailable​

ProjectToVest​

Parameters​

Example​

ProjectToVestLocation​

Parameters​

CustomProjectToVest​

Referenzen

Statische Funktionen — Event-gesteuerte Haptik abspielen

PlayHaptic

Parameters

Returns

Example

PlayHapticWithOption

Parameters

Returns

Example

PlayWithStartTime

Parameters

Returns

Example

PlayLoop

Parameters

Returns

Example

Statische Funktionen — Haptik direkt abspielen

PlayDot

Parameters

Returns

Example

PlayPath

Parameters

Returns

Example

PlayWaveform

Parameters

Returns

Example

Statische Funktionen — Sonstige

StopHapticByEventId

StopHapticByRequestId

StopHaptic

PauseHapticByEventId

ResumeHapticByEventId

IsPlaying

IsPlayingByEventId

IsPlayingByRequestId

Initialize

Ping

PingAll

Destroy

GetBhapticsDevices

IsBhapticsAvailable

ProjectToVest

Parameters

Example

ProjectToVestLocation

Parameters

CustomProjectToVest