Objets audio

Les objets audio modulaires de Roblox vous permettent d'avoir un contrôle dynamique sur le son et le chat vocal dans vos expériences. Presque chaque objet audio correspond à un appareil audio du monde réel, et ils fonctionnent tous ensemble pour capturer et jouer de l'audio comme leurs homologues physiques.

Par exemple, chaque objet audio appartient conceptuellement aux catégories suivantes :

• Objets qui produisent des flux audio, tels que les lecteurs audio.
• Objets qui consomment des flux audio, tels que les émetteurs audio.
• Objets qui modifient les flux audio, tels que les effets audio.
• Objets qui transportent les flux audio d'un objet audio à un autre, comme les câbles.

En lisant ce guide et en apprenant comment tous ces objets audio fonctionnent ensemble pour émettre du son, vous apprendrez à capturer et à transmettre précisément de la musique, des effets sonores et la voix humaine de l'expérience au joueur et inversement.

Lecture audio

Pour jouer de l'audio dans votre expérience, il est important de comprendre le rôle de chaque objet audio disponible :

• Un AudioPlayer charge et joue le fichier audio en utilisant un ID d'actif audio défini.
• Un AudioEmitter est un haut-parleur virtuel qui émet de l'audio dans l'environnement 3D.
• Un AudioListener est un microphone virtuel qui capte l'audio de l'environnement 3D.
• Un AudioDeviceOutput est un dispositif matériel physique dans le monde réel, tel qu'un haut-parleur ou des écouteurs.
• Un AudioDeviceInput est un microphone physique dans le monde réel.
• L'objet AudioTextToSpeech convertit le texte en audio à l'aide d'une voix humaine artificielle.
• L'objet AudioSpeechToText convertit l'audio parlé en texte.
• Un Wire transportent des flux audio d'un objet audio à un autre.

Comment vous associez ces objets audio dépend de si vous souhaitez émettre de l'audio directement aux haut-parleurs ou écouteurs du joueur ou depuis des objets dans l'espace 3D. Les sections suivantes détaillent les deux scénarios.

Audio 2D

L'audio 2D est un son non directionnel qui joue depuis aucun emplacement particulier, restant au même volume indépendamment de la position ou de l'orientation du joueur dans l'espace 3D. Ce type d'audio nécessite trois objets audio :

• Un lecteur audio pour produire un flux audio.
• Un dispositif matériel physique pour lire le flux audio dans le monde réel.
• Un câble pour transporter le flux audio du lecteur audio vers le dispositif de sortie.

Pour démontrer comment configurer ces objets audio dans Studio pour de l'audio 2D, le diagramme suivant compare chaque objet avec leur homologue matériel audio dans le monde réel. En résumé :

• Le AudioPlayer charge et joue votre actif audio avec les paramètres spécifiés.
• Le AudioDeviceOutput permet au joueur d'entendre l'audio via leurs haut-parleurs ou écouteurs.
• Le Wire se connecte au lecteur audio avec sa propriété SourceInstance, et au dispositif matériel avec sa propriété TargetInstance. Il agit ensuite comme un pont pour transporter le flux audio du lecteur audio vers le dispositif de sortie du joueur.

Pour jouer de l'audio non directionnel :

1. Dans la fenêtre Explorer, allez à SoundService et insérez les éléments suivants :

   1. Un objet AudioPlayer pour créer une source audio.
   2. Un objet AudioDeviceOutput pour créer un haut-parleur qui joue à travers l'expérience.
   3. Un objet Wire pour connecter le flux du lecteur audio au haut-parleur.
2. Dans la fenêtre Propriétés de l'objet AudioPlayer :

   1. Définissez AssetID sur un ID d'actif audio valide. Si vous n'avez pas votre propre audio personnalisé, vous pouvez trouver des actifs audio gratuits dans le Creator Store.
   2. Activez Looping si vous souhaitez que votre audio se répète en continu.
   3. Définissez Volume sur l'unité d'amplitude que vous souhaitez pour la lecture de votre audio.
3. Dans la fenêtre Propriétés de l'objet Wire :

   1. Définissez SourceInstance sur l'AudioPlayer pour spécifier que vous souhaitez jouer l'audio dans ce lecteur audio spécifique.
   2. Définissez TargetInstance sur l'AudioDeviceOutput pour spécifier que vous souhaitez jouer l'audio à partir de ce haut-parleur spécifique.

À partir de là, vous pouvez déclencher votre audio non directionnel avec des scripts pour le jouer lorsque les joueurs rejoignent l'expérience ou à la suite d'un événement de jeu ou d'une interaction UI. Pour des références d'exemples de code pour ces cas d'utilisation, consultez le tutoriel Ajouter de l'audio 2D.

Audio 3D

L'audio 3D est un son directionnel qui joue depuis un emplacement particulier dans l'espace 3D, augmentant ou diminuant en volume en fonction de la position et de l'orientation du joueur par rapport au son. Ce type d'audio nécessite six objets audio :

• Un lecteur audio pour produire un flux audio.
• Un émetteur audio pour émettre le flux audio dans l'environnement.
• Un auditeur pour capter le flux audio de l'environnement.
• Un dispositif matériel physique pour jouer le flux audio dans le monde réel.
• Deux câbles : un pour transporter le flux audio du lecteur audio à l'émetteur, et un autre pour le transporter de l'auditeur au dispositif de sortie.

Pour démontrer comment configurer ces objets audio dans Studio pour de l'audio 3D, le diagramme suivant compare chaque objet avec leur homologue matériel audio dans le monde réel. En résumé :

• Le AudioPlayer charge et joue votre actif audio avec les paramètres spécifiés.
• La position parent de l'AudioEmitter dans l'espace 3D détermine où ce son sera émis dans l'environnement.
• L'AudioListener capte soit l'audio de l'émetteur depuis la caméra locale ou depuis la Humanoid.RootPart du personnage du joueur, selon l'endroit où vous définissez la position par défaut de l'auditeur.
• Le AudioDeviceOutput permet au joueur d'entendre l'audio via leurs haut-parleurs ou écouteurs.
• Le premier Wire se connecte au lecteur audio avec sa propriété SourceInstance, et à l'émetteur avec sa propriété TargetInstance. Il agit ensuite comme un pont pour transporter le flux audio du lecteur audio à l'émetteur.
• Le second Wire se connecte à l'auditeur avec sa propriété SourceInstance, et au dispositif matériel avec sa propriété TargetInstance. Il agit ensuite comme un pont pour transporter le flux audio de l'auditeur au dispositif de sortie du joueur.

Pour jouer de l'audio positionnel :

1. Choisissez où vous souhaitez créer un AudioListener lorsque les joueurs apparaissent dans l'expérience.

   1. Dans la fenêtre Explorer, sélectionnez SoundService.
   2. Dans la fenêtre Propriétés, définissez ListenerLocation sur l'une des options suivantes :

      • Default - Crée et parent l'auditeur à Workspace.CurrentCamera dans les expériences qui activent le chat vocal.
      • None - Ne crée pas d'auditeur. Cette option est utile si vous souhaitez créer un auditeur via un script.
      • Character - Crée et parent un auditeur au personnage local du joueur.
      • Camera - Crée et parent l'auditeur à Workspace.CurrentCamera.

   Lorsque vous définissez ListenerLocation sur Character ou Camera, le moteur crée automatiquement un objet AudioDeviceOutput sous SoundService à l'exécution.

2. Dans la fenêtre Explorer, allez à l'objet 3D dont vous souhaitez émettre de l'audio et insérez les éléments suivants :

   1. Un objet AudioPlayer pour créer une source audio.
   2. Un objet AudioEmitter pour émettre un flux positionnel depuis l'objet 3D.
   3. Un objet Wire pour connecter le flux du générateur de parole audio à l'émetteur audio.

3. Dans la fenêtre Propriétés de l'objet AudioPlayer :

   1. Définissez AssetID sur un ID d'actif audio valide. Si vous n'avez pas votre propre audio personnalisé, vous pouvez trouver des actifs audio gratuits dans le Creator Store.
   2. Activez Looping si vous souhaitez que votre audio se répète en continu.
   3. Définissez Volume sur l'unité d'amplitude que vous souhaitez pour la lecture de votre audio.

4. Dans la fenêtre Propriétés de l'objet AudioEmitter, définissez DistanceAttenuation sur une courbe de volume par distance qui détermine à quel point l'auditeur entend l'émetteur en fonction de la distance entre eux.

   Par exemple, la courbe suivante diminue le volume de l'audio de moitié lorsque l'auditeur se trouve à 50 unités de l'émetteur, puis diminue brusquement le volume à zéro lorsque l'auditeur se trouve à 70 unités.

   

5. Dans la fenêtre Propriétés de l'objet Wire :

   1. Définissez SourceInstance sur l'AudioPlayer pour spécifier que vous souhaitez jouer l'audio dans ce lecteur audio spécifique.
   2. Définissez TargetInstance sur l'AudioEmitter pour spécifier que vous souhaitez jouer l'audio à partir de cet émetteur audio spécifique.

À partir de là, vous pouvez déclencher votre audio directionnel avec des scripts pour le jouer lorsque les joueurs rejoignent l'expérience ou à la suite d'un événement de jeu ou d'une interaction UI. Pour des références d'exemples de code pour ces cas d'utilisation, consultez le tutoriel Ajouter de l'audio 3D.

Text-to-speech

Le text-to-speech (TTS) est une forme de technologie d'assistance qui convertit des chaînes de texte en sons de parole à l'aide d'une voix artificielle. Ce type d'audio nécessite cinq objets audio :

• Un générateur de parole audio pour charger et convertir le texte en audio.
• Un émetteur audio pour émettre le flux audio dans l'environnement.
• Un auditeur pour capter le flux audio de l'environnement.
• Un dispositif matériel physique pour jouer le flux audio dans le monde réel.
• Pour l'audio 2D - Un câble pour transporter le flux audio du générateur de parole audio vers le dispositif de sortie.
• Pour l'audio 3D - Deux câbles : un pour transporter le flux audio du générateur de parole audio à l'émetteur, et un autre pour le transporter de l'auditeur au dispositif de sortie.

Comment vous configurez ces objets dépend de si vous souhaitez créer un audio TTS 2D ou 3D. Pour plus de détails sur chaque processus, cliquez entre les onglets suivants.

Pour démontrer comment configurer ces objets audio dans Studio pour de l'audio TTS 2D, le diagramme suivant compare chaque objet avec leur homologue matériel audio dans le monde réel. En résumé :

• L'objet AudioTextToSpeech charge et convertit des chaînes de texte en sons de parole.
• Le AudioDeviceOutput permet au joueur d'entendre l'audio via leurs haut-parleurs ou écouteurs.
• Le Wire se connecte au générateur de parole audio avec sa propriété SourceInstance, et au dispositif matériel avec sa propriété TargetInstance. Il agit ensuite comme un pont pour transporter le flux audio du générateur de parole à l'appareil de sortie du joueur.

Pour jouer l'audio text-to-speech 2D :

1. Dans la fenêtre Explorer, allez à SoundService et insérez les éléments suivants :

   1. Un objet AudioTextToSpeech pour créer un générateur de parole audio.
   2. Un objet AudioDeviceOutput pour créer un haut-parleur qui joue à travers l'expérience.
   3. Un objet Wire pour connecter le flux du générateur de parole audio au haut-parleur.
2. Dans la fenêtre Propriétés de l'objet AudioTextToSpeech :

   1. Définissez Text sur ce que vous voulez que la voix dise. Il y a une limite de 300 caractères par requête.

   2. Définissez VoiceId sur un numéro entre 1 et 10, selon la voix artificielle que vous souhaitez utiliser dans le tableau suivant.

      Liste des voix artificielles

      VoiceID	Description de la voix	Exemple audio
      1	Homme britannique
      2	Femme britannique
      3	Homme des États-Unis #1
      4	Femme des États-Unis #1
      5	Homme des États-Unis #2
      6	Femme des États-Unis #2
      7	Homme australien
      8	Femme australienne
      9	Voix rétro #1
      10	Voix rétro #2
      11	Voix de l'hôte
      101	Homme espagnol
      102	Femme espagnole
      201	Homme allemand
      202	Femme allemande
      301	Homme italien
      302	Femme italienne
      401	Homme français
      402	Femme française

      
      

   3. Définissez Volume sur l'unité d'amplitude que vous souhaitez pour la lecture de votre audio.

3. Dans la fenêtre Propriétés de l'objet Wire :

   1. Définissez SourceInstance sur l'AudioTextToSpeech pour spécifier que vous souhaitez jouer l'audio à partir de ce générateur de parole audio spécifique.
   2. Définissez TargetInstance sur l'AudioDeviceOutput pour spécifier que vous souhaitez jouer l'audio à partir de cet haut-parleur spécifique.

À partir de là, vous pouvez déclencher votre audio TTS avec des scripts. Pour des références d'exemples de code pour l'audio TTS, y compris comment configurer un TTS contextuel qui s'adapte au joueur, à l'état de leur environnement ou à la situation de jeu, consultez le tutoriel Ajouter du text-to-speech.

Speech-to-text

La reconnaissance vocale en texte (STT) est une forme de technologie qui génère automatiquement des chaînes de texte à partir de sons de parole. Ce type d'audio nécessite trois objets audio :

• Un générateur de texte pour charger et convertir l'audio en texte.
• Un dispositif matériel physique comme un microphone pour capturer l'entrée audio.
• Un câble pour transporter le flux audio du dispositif d'entrée au générateur de texte.

Tous ces objets audio travaillent ensemble pour générer du texte STT en réponse aux actions des joueurs. Par exemple, si le joueur porte un casque tout en jouant à une expérience avec son ordinateur portable :

• L'AudioDeviceInput capture la parole du joueur, comme prononcée dans leur microphone et comme un flux audio.
• Un Wire transporte le flux audio de l'AudioDeviceInput au AudioSpeechToText.
• Le AudioSpeechToText convertit la parole du joueur en texte.
• L'expérience lit ce texte et effectue une action, comme afficher le texte prononcé à l'écran ou ouvrir une porte à la demande du joueur.

Pour implémenter la reconnaissance vocale en texte dans votre expérience :

1. Activez l'utilisation de la dernière API pour la voix.

   1. Dans la fenêtre Explorer, sélectionnez le VoiceChatService.
   2. Dans la fenêtre Propriétés, définissez UseAudioApi sur Enabled.
2. Dans la fenêtre Explorer, allez à SoundService et insérez les éléments suivants :

   1. Un AudioDeviceInput pour capturer la parole.
   2. Un AudioSpeechToText pour convertir la parole en texte.
   3. Un Wire pour transporter le flux du dispositif d'entrée audio à l'instance STT.
3. Dans la fenêtre Propriétés de l'objet AudioSpeechToText, définissez l'état Enabled sur activé.
4. Dans la fenêtre Propriétés de l'objet Wire :

   1. Définissez SourceInstance sur votre nouvel AudioDeviceInput pour spécifier que vous souhaitez que le câble transporte audio de cette instance audio spécifique.
   2. Définissez TargetInstance sur votre nouvel AudioSpeechToText pour spécifier que vous souhaitez que le câble transporte audio vers cette instance audio spécifique.
5. Définissez la propriété Player du dispositif d'entrée audio sur le joueur local à l'exécution avec audioDeviceInput.Player = game.Players.LocalPlayer. Cela indique à Roblox de quel utilisateur le microphone doit capturer l'audio.

Après avoir configuré le STT dans votre expérience, vous pouvez le déclencher avec des scripts. Pour des références d'exemples de code, consultez le tutoriel Ajouter la reconnaissance vocale en texte.

Langues prises en charge

Aucune configuration n'est requise pour activer les langues prises en charge. Roblox détecte automatiquement la langue parlée à partir de l'audio et la transcrit.

STT prend en charge les langues suivantes :

• Arabe
• Chinois (simplifié)
• Chinois (traditionnel)
• Anglais
• Français
• Allemand
• Indonésien
• Italien
• Japonais
• Coréen
• Polonais
• Portugais
• Espagnol
• Russe
• Turc
• Thaïlandais
• Vietnamien

Filtrer les mots similaires

Lorsque vous mettez en œuvre le STT dans votre expérience, vous souhaiterez peut-être améliorer la précision de la correspondance en filtrant les mots qui sonnent similaires à ceux que vous souhaitez réellement que le joueur dise. Pour ce faire, vous pouvez comparer les mots reconnus par AudioSpeechToText avec des listes de mots connus :

1. Nettoyez et tokenisez la sortie Text de AudioSpeechToText pour créer un tableau de chaînes minuscules pouvant être analysées et comparées.

   1. Supprimez les caractères de ponctuation.
   2. Convertissez l'ensemble de la chaîne en minuscules.
   3. Divisez la chaîne par des espaces pour produire un tableau de mots.
2. Générez des tableaux candidats pour préparer vos chaînes à la comparaison.

   1. Nettoyez et tokenisez chaque chaîne de référence.
   2. Stockez ces mots traités dans un tableau séparé.
3. Comparez et associez les mots des deux tableaux pour reconnaître les entrées vocales qui sont proches de vos phrases cibles, même si elles incluent de petites variations.

   • Pour des vérifications simples, vérifiez si les chaînes sont exactement les mêmes.
   • Pour une correspondance plus flexible, vous pouvez écrire une logique personnalisée pour accepter des substitutions (comme "couleur" au lieu de "color") ou faire correspondre un sous-ensemble de mots et calculer un score de similarité.

Personnaliser l'audio

Les effets audio vous permettent de modifier ou d'améliorer non destructivement les flux audio avant qu'ils n'atteignent les oreilles d'un joueur. Vous pouvez appliquer ces effets pour rendre votre audio plus immersif dans les expériences, comme utiliser un objet AudioEqualizer pour rendre le son de la pluie étouffé, un objet AudioCompressor pour contrôler le volume maximal d'un son, ou AudioReverb pour ajouter des réflexions sonores plus réalistes dans les espaces intérieurs.

Pour des instructions sur la façon de configurer les effets audio, ainsi que des comparaisons côte à côte de l'audio avant et après personnalisation, consultez Effets audio.

Déclencher l'audio

Vous pouvez déclencher l'audio contextuellement à partir d'un script en appelant Play() sur un objet AudioPlayer correctement câblé. Par exemple, si vous parent un script à un lecteur audio, vous pouvez déclencher l'actif audio via quelque chose comme ça :

local audio = script.Parent
local quelqueChose = ...
quelqueChose.SomeEvent:Connect(function()
    audio:Play()
end)

Pour des exemples de code plus complexes pour déclencher de l'audio, tels que pour des retours de jeu, des interactions UI et du bruit de fond en boucle, consultez les tutoriels Ajouter de l'audio 2D, Ajouter de l'audio 3D et Ajouter text-to-speech.