Cette page a été traduite automatiquement et peut contenir des erreurs. Voir l’original en anglais

Class UBhapticsSDK2

Hérite de UBlueprintFunctionLibrary

La classe UBhapticsSDK2 contient les fonctions permettant d'utiliser les périphériques haptiques de bHaptics.

Références


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

Fonctions statiques — Lecture haptique basée sur les événements

Lit les motifs haptiques liés à un événement haptique spécifique créé depuis Designer/Portal. Nous vous recommandons vivement d'utiliser ces fonctions.

PlayHaptic

static int PlayHaptic(FString eventId);

Lit l'événement haptique. C'est la manière la plus simple d'appeler un événement haptique. Cette fonction possède la plus faible surcharge parmi toutes les fonctions d'appel d'événement haptique.

Paramètres

FString eventId: Nom de l'événement haptique que vous souhaitez lire.

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Lit l'événement haptique en ajustant l'intensité, la durée et la direction du retour haptique.

Paramètres

FString eventId: Nom de l'événement haptique que vous souhaitez lire.
float intensity: L'Intensity haptique est multipliée par cette valeur.
float duration: La Duration haptique est multipliée par cette valeur.
float angleX: Fait pivoter le retour haptique dans le sens antihoraire autour du Vector3.up global. Plage valide : [0.0f - 360.0f]
float offsetY: Déplace le retour haptique vers le haut ou vers le bas. Plage valide : [-0.5f - 0.5f]

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Lit l'événement haptique en ajustant l'intensité, la durée et la direction du retour haptique.

Paramètres

FString eventId: Nom de l'événement haptique que vous souhaitez lire.
int startMillis: Position de départ de la lecture en millisecondes. Les premiers startMillis millisecondes de l'événement sont ignorées (il s'agit d'un Offset de départ, pas d'un délai avant la lecture). La valeur par défaut est 0. Windows/macOS/Android only.
float intensity: L'Intensity haptique est multipliée par cette valeur.
float duration: La Duration haptique est multipliée par cette valeur.
float angleX: Fait pivoter le retour haptique dans le sens antihoraire autour du Vector3.up global. Plage valide : [0.0f - 360.0f]
float offsetY: Déplace le retour haptique vers le haut ou vers le bas. Plage valide : [-0.5f - 0.5f]

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Lit le retour haptique de façon répétée. De plus, comme la fonction PlayHapticWithOption, vous pouvez ajuster l'intensité, la durée et la direction du retour haptique.

Paramètres

FString eventId: Nom de l'événement haptique que vous souhaitez lire.
float intensity: L'Intensity haptique est multipliée par cette valeur.
float duration: La Duration haptique est multipliée par cette valeur.
float angleX: Fait pivoter le retour haptique dans le sens antihoraire autour du Vector3.up global. Plage valide : [0.0f - 360.0f]
float offsetY: Déplace le retour haptique vers le haut ou vers le bas. Plage valide : [-0.5f - 0.5f]
int interval: L'intervalle de temps entre les boucles, exprimé en millisecondes.
int maxCount: Le nombre de boucles.

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Fonctions statiques — Lecture haptique directe

Si vous souhaitez lire des retours haptiques sans créer de nouvel événement, utilisez ces fonctions.

PlayDot

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

Lit le retour haptique sur l'actionneur haptique spécifié. Vous pouvez utiliser cette fonction sans créer d'événement.

Paramètres

int position: Type de périphérique haptique. Pour plus d'informations, veuillez consulter ici.

Valeur	Périphérique	Identique à…	Nombre de moteurs
`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: Définissez la longueur du tableau en fonction du nombre de moteurs du périphérique. Les valeurs du tableau représentent l'Intensity des moteurs. Plage valide pour chaque valeur : [0 - 100]
float seconds: La Duration du retour haptique, exprimée en secondes. Une valeur supérieure ou égale à 0.1f est recommandée.

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Lit le retour haptique autour de coordonnées spécifiques. Contrairement à la fonction PlayDot, qui spécifie individuellement l'Intensity haptique pour chaque actionneur, cette méthode spécifie l'Intensity haptique pour des coordonnées particulières.

Lors de la spécification de la position haptique, PlayDot offre un contrôle discret, tandis que PlayPath est plus continu. PlayDot attribue une Intensity à chaque actionneur individuellement, tandis que PlayPath attribue une Intensity à des coordonnées spécifiques (entre 0 et 1 pour les axes X et Y), ce qui entraîne la vibration des actionneurs à proximité en conséquence.

Vous pouvez placer plusieurs coordonnées avec plusieurs intensités dans le tableau. Notez que tous les actionneurs autour de ces coordonnées dans le tableau s'activeront simultanément (au même instant), et non séquentiellement. De plus, la taille de tous les tableaux doit être identique.

En appelant continuellement cette fonction tout en modifiant progressivement les valeurs, vous pouvez obtenir l'effet d'un point haptique en mouvement.

[TactGlove DK3] PlayPath ne pilote pas le moteur à bobine mobile (VCM) du poignet sur un gant DK3.

Frame 82.png

Paramètres

int position: Type de périphérique haptique.

Valeur	Périphérique	Identique à…
`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: Définit la coordonnée X. Plage valide pour chaque valeur : [0.0f - 1.0f]
TArray<float> y: Définit la coordonnée Y. Plage valide pour chaque valeur : [0.0f - 1.0f]
TArray<int> motorValues: Définissez la longueur du tableau en fonction du nombre de coordonnées. Les valeurs du tableau représentent l'Intensity des coordonnées. Plage valide pour chaque valeur : [0 - 100]
float seconds: La Duration du retour haptique, exprimée en secondes. Une valeur supérieure ou égale à 0.1f est recommandée.

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

TactGlove uniquement. Lit des retours haptiques sur le TactGlove. Contrairement à PlayDot, vous pouvez régler finement la Duration haptique et les variations d'Intensity de vibration. Cela permet une expression encore plus précise du retour haptique.

Chaque tableau (motorIntensities, playTimeValues, shapeValues) doit contenir six éléments pour TactGlove DK2 ou huit éléments pour TactGlove DK3, et les trois tableaux doivent avoir la même longueur. Toute autre longueur retourne -1.

Paramètres

int position: Type de périphérique haptique.

Valeur Périphérique Identique à…
8 TactGlove(Left) EBhapticsDevicePosition::GloveL
9 TactGlove(Right) EBhapticsDevicePosition::GloveR

Valeur	Périphérique	Identique à…
`8`	TactGlove(Left)	`EBhapticsDevicePosition::GloveL`
`9`	TactGlove(Right)	`EBhapticsDevicePosition::GloveR`

TArray<int> motorIntensities: Un tableau représentant l'Intensity de chaque moteur. Sa longueur doit correspondre au nombre de moteurs du TactGlove : six (TactGlove DK2) ou huit (TactGlove DK3). Les moteurs de la paume aux indices de tableau 6 et 7 (dans le tableau ci-dessous) existent uniquement sur le DK3. Plage valide pour chaque valeur : [0 - 100]

Index du tableau	Position du moteur…
`0`	Bout du pouce
`1`	Bout de l'index
`2`	Bout du majeur
`3`	Bout de l'annulaire
`4`	Bout de l'auriculaire
`5`	Sur le poignet
`6`	Sur la paume (côté pouce)
`7`	Sur la paume (côté auriculaire)

TArray<EBhapticsGlovePlayTime> playTimeValues: Un tableau de même longueur que motorIntensities (six pour DK2, huit pour DK3), chaque élément représentant un intervalle de temps d'activation, défini à l'aide des enums EBhapticsGlovePlayTime.

Valeur	Duration	Identique à…
`EBhapticsGlovePlayTime::None`	Aucune	`0`
`EBhapticsGlovePlayTime::FiveMS`	5ms	`1`
`EBhapticsGlovePlayTime::TenMS`	10ms	`2`
`EBhapticsGlovePlayTime::TwentyMS`	20ms	`4`
`EBhapticsGlovePlayTime::ThirtyMS`	30ms	`6`
`EBhapticsGlovePlayTime::FortyMS`	40ms	`8`

TArray<EBhapticsGloveShapeValue> shapeValues: Un tableau de même longueur que motorIntensities (six pour DK2, huit pour DK3), chaque élément représentant la forme des variations d'Intensity haptique dans le temps, spécifiée par les enums EBhapticsGloveShapeValue.

Valeur	Forme d'onde	Identique à…
`EBhapticsGloveShapeValue::Constant`	Intensity constante pendant la Duration	`0`
`EBhapticsGloveShapeValue::Decreasing`	Commence à l'Intensity spécifiée et diminue de moitié	`1`
`EBhapticsGloveShapeValue::Increasing`	Commence à la moitié de l'Intensity spécifiée et augmente jusqu'à l'Intensity spécifiée.	`2`

[TactGlove DK3] Sur le gant DK3, l'actionneur du poignet (index de tableau 5) est un moteur à bobine mobile (VCM) et ne reflète pas les shapeValues. Les sept autres moteurs appliquent la forme d'onde de la même manière que sur les gants DK2.

int frequency: [TactGlove DK3 only] Fréquence de vibration en Hz des actionneurs propres au gant DK3. La valeur par défaut est 80. Cela n'affecte que le gant DK3 lui-même et ne modifie pas la fréquence de fonctionnement de tout autre périphérique connecté. N'a aucun effet sur les gants DK2 ni sur le chemin universel (non-Windows/macOS). Windows/macOS only.
int repeatCount: Nombre de répétitions de la forme d'onde, à partir de 1. 0 la joue une seule fois. Windows/macOS only.

Valeur de retour

Request ID. Vous pouvez utiliser le Request ID pour arrêter le retour haptique. Retourne -1 en cas d'échec.

Cependant, lorsqu'il est connecté au Hub, les appels échoués ne retournent pas -1 car le Hub ne fournit pas de valeur de retour.

Exemple

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

Fonctions statiques — Autres

StopHapticByEventId

static bool StopHapticByEventId(FString eventId);

Arrête l'événement haptique par Event ID. Retourne si l'arrêt a réussi.

#include "BhapticsSDK2.h"

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

StopHapticByRequestId

static bool StopHapticByRequestId(int requestId);

Arrête l'événement haptique en utilisant le Request ID retourné par la fonction qui exécute le retour haptique. Retourne si l'arrêt a réussi.

#include "BhapticsSDK2.h"

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

StopHaptic

static bool StopHaptic();

Arrête tous les retours haptiques en cours de lecture. Retourne si l'arrêt a réussi.

#include "BhapticsSDK2.h"

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

    UBhapticsSDK2::StopHaptic();
}

PauseHapticByEventId

static void PauseHapticByEventId(FString eventId);

Met en pause l'événement haptique par Event ID. La position de lecture est conservée afin de pouvoir reprendre ultérieurement avec ResumeHapticByEventId.

#include "BhapticsSDK2.h"

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

ResumeHapticByEventId

static void ResumeHapticByEventId(FString eventId);

Reprend un événement haptique précédemment mis en pause avec PauseHapticByEventId, en continuant depuis la position où il a été mis en pause.

#include "BhapticsSDK2.h"

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

IsPlaying

static bool IsPlaying();

Vérifie si le retour haptique est en cours de lecture.

#include "BhapticsSDK2.h"

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

IsPlayingByEventId

static bool IsPlayingByEventId(FString eventId);

Vérifie si l'événement haptique correspondant à cet Event ID est en cours de lecture.

#include "BhapticsSDK2.h"

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

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

IsPlayingByRequestId

static bool IsPlayingByRequestId(int requestId);

Vérifie si l'événement haptique correspondant à ce Request ID est en cours de lecture.

#include "BhapticsSDK2.h"

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

Initialize

static void Initialize();

Initialise l'environnement haptique. Cette fonction doit être appelée avant d'utiliser les fonctions liées au retour haptique.

Ping

static void Ping(FBhapticsDevice device);

Envoie un retour haptique simple à un périphérique spécifique.

PingAll

static void PingAll();

Envoie un retour haptique simple à tous les périphériques connectés.

Destroy

static void Destroy();

Détruit l'environnement haptique. Cette fonction doit être appelée à la fin du jeu et ne doit être appelée QU'UNE SEULE FOIS.

GetBhapticsDevices

static TArray<FBhapticsDevice> GetBhapticsDevices();

Obtient un tableau d'informations sur les périphériques haptiques connectés.

IsBhapticsAvailable

static bool IsBhapticsAvailable();

Vérifie si l'environnement haptique est initialisé et prêt à utiliser les fonctions liées au retour haptique.

ProjectToVest

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

Fonction utilitaire permettant de calculer les valeurs d'Offset (angle et hauteur) d'un point de contact de collision donné par rapport au joueur. Ces valeurs d'Offset peuvent être utilisées dans PlayHapticWithOption et PlayLoop pour ajuster la position haptique.

Cette fonction suppose que la direction avant est alignée avec l'avant du gilet, et la position du joueur est considérée comme l'origine.

Consultez l'exemple ci-dessous pour des informations détaillées.

Paramètres

FVector ContactLocation: Point de contact en coordonnées globales.
UPrimitiveComponent* PlayerComponent: Référence au composant primitif attaché au joueur.
float HalfHeight: La moitié de la hauteur réelle du joueur, exprimée en centimètres.

Exemple

Supposons l'implémentation d'un retour haptique lorsque le joueur est touché par une balle dans un jeu VR. Le motif haptique correspondant à cet événement serait un retour haptique court et intense au centre avant du TactSuit. Pour renforcer le réalisme, il serait idéal de faire varier la hauteur et l'angle du retour haptique selon l'endroit où le joueur est touché.

Les fonctions PlayHapticWithOption et PlayLoop permettent d'ajuster la hauteur et l'angle du motif haptique. Ces fonctions prennent des valeurs d'angle (OffsetAngleX) et de hauteur (OffsetY) pour l'ajustement haptique.

La fonction ProjectToVest calcule les valeurs d'angle et de hauteur en fonction de l'endroit où le joueur est touché, des informations de transform du joueur et de la taille de l'utilisateur. Ces valeurs sont ensuite encapsulées dans la structure FBhapticsRotationOption et retournées.

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

Fonction utilitaire permettant de calculer les valeurs d'Offset à partir d'un emplacement de contact et des informations de transform du joueur. Similaire à ProjectToVest, mais ne calcule que l'Offset angulaire (OffsetAngleX). La hauteur (OffsetY) sera toujours 0.

Paramètres

FVector ContactLocation: Point de contact en coordonnées globales.
FVector PlayerLocation: Emplacement du joueur.
FRotator PlayerRotation: Rotation du joueur.

CustomProjectToVest

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

Fonction utilitaire permettant de calculer les valeurs d'Offset à partir d'une collision. Remplit la même fonction que ProjectToVest, mais permet de modifier les vecteurs Forward et Up.

FVector ContactLocation: Point de contact en coordonnées globales.
UPrimitiveComponent* PlayerComponent: Référence au composant primitif attaché au joueur.
float HalfHeight: La moitié de la hauteur réelle du joueur, exprimée en centimètres.
FVector UpVector: Vecteur de direction vers le haut de référence pour le calcul d'Offset.
FVector ForwardVector: Vecteur de direction vers l'avant de référence pour le calcul d'Offset.

Références​

Fonctions statiques — Lecture haptique basée sur les événements​

PlayHaptic​

Paramètres​

Valeur de retour​

Exemple​

PlayHapticWithOption​

Paramètres​

Valeur de retour​

Exemple​

PlayWithStartTime​

Paramètres​

Valeur de retour​

Exemple​

PlayLoop​

Paramètres​

Valeur de retour​

Exemple​

Fonctions statiques — Lecture haptique directe​

PlayDot​

Paramètres​

Valeur de retour​

Exemple​

PlayPath​

Paramètres​

Valeur de retour​

Exemple​

PlayWaveform​

Paramètres​

Valeur de retour​

Exemple​

Fonctions statiques — Autres​

StopHapticByEventId​

StopHapticByRequestId​

StopHaptic​

PauseHapticByEventId​

ResumeHapticByEventId​

IsPlaying​

IsPlayingByEventId​

IsPlayingByRequestId​

Initialize​

Ping​

PingAll​

Destroy​

GetBhapticsDevices​

IsBhapticsAvailable​

ProjectToVest​

Paramètres​

Exemple​

ProjectToVestLocation​

Paramètres​

CustomProjectToVest​

Références

Fonctions statiques — Lecture haptique basée sur les événements

PlayHaptic

Paramètres

Valeur de retour

Exemple

PlayHapticWithOption

Paramètres

Valeur de retour

Exemple

PlayWithStartTime

Paramètres

Valeur de retour

Exemple

PlayLoop

Paramètres

Valeur de retour

Exemple

Fonctions statiques — Lecture haptique directe

PlayDot

Paramètres

Valeur de retour

Exemple

PlayPath

Paramètres

Valeur de retour

Exemple

PlayWaveform

Paramètres

Valeur de retour

Exemple

Fonctions statiques — Autres

StopHapticByEventId

StopHapticByRequestId

StopHaptic

PauseHapticByEventId

ResumeHapticByEventId

IsPlaying

IsPlayingByEventId

IsPlayingByRequestId

Initialize

Ping

PingAll

Destroy

GetBhapticsDevices

IsBhapticsAvailable

ProjectToVest

Paramètres

Exemple

ProjectToVestLocation

Paramètres

CustomProjectToVest