Introduction au développement Wwise et de plugins personnalisés

Wwise (Wave Works Interactive Sound Engine) by Audiokinetic est l'une des solutions audio intermediaware les plus utilisées dans les industries du jeu et des médias interactifs. Il fournit un ensemble d'outils complet pour les concepteurs de sons et les programmeurs audio pour gérer, mélanger et mettre en œuvre des actifs audio en temps réel. Bien que la suite standard de Wwise comprend une solide bibliothèque d'effets intégrés (réverbérations, retards, compresseurs, etc.) et des plugins sources, de nombreux projets exigent un traitement sonore unique qui va au-delà de ces valeurs par défaut.

La demande de traitement audio sur mesure dans les jeux et les expériences interactives a augmenté de façon significative. Les joueurs modernes attendent des paysages sonores immersifs qui réagissent dynamiquement à chaque événement dans le jeu. Les effets hors-ligne sont souvent courts lorsqu'ils tentent d'obtenir un son signature pour votre projet. En plongeant dans le développement de plugins Wwise, vous prenez le contrôle de chaque aspect du pipeline audio, du traitement de l'échantillon au réglage de paramètres de haut niveau via les RTPC. Ce guide suppose que vous avez une connaissance pratique des concepts audio C++ et numérique, mais explique chaque étape en suffisamment de détails pour vous faire démarrer à partir de zéro.

Comprendre l'architecture des plugins Wwise

Avant de plonger dans le code, il est essentiel de comprendre la structure d'un plugin Wwise. Les plugins sont des bibliothèques de liens dynamiques (DLLs) qui interfacent avec Wwise à travers le SDK WWAY. Le SDK fournit des classes de base et des interfaces que vous devez implémenter pour créer des plugins d'effet (FX), des plugins source ou des plugins de traitement. L'architecture se compose de trois couches principales:

  • Interface de greffon : Le point d'entrée principal qui enregistre le plugin avec Wwise, définit ses paramètres, et fournit la fonction d'usine pour créer des instances.
  • Moteur de traitement: Le noyau où vit votre algorithme DSP. Ceci est généralement implémenté dans une classe qui hérite de et implémente la méthode , qui est appelée pour chaque tampon audio.
  • GUI (Authoring wise): Si votre plugin a des paramètres configurables, vous pouvez créer une interface utilisateur personnalisée en utilisant le cadre de plugin WWise. Cette partie utilise l'API auteur pour présenter des commandes comme les curseurs, les déroulants et les graphiques dans l'éditeur de projet WWise.

Les greffons peuvent être plugins d'effet (processus d'entrée audio et de sortie), plugins source (générer l'audio à partir de zéro, comme un synthétiseur), ou plugins metasound (enveloppes, LFO, etc.). L'approche de développement est similaire pour tous les types, mais les classes de base diffèrent légèrement. Nous nous concentrerons sur les plugins d'effet comme le cas d'utilisation le plus commun.

Composantes clés du SDK WWise

Le SDK WWise est disponible en téléchargement sur le site Audiokinetic. Il comprend les fichiers d'en-tête, les bibliothèques statiques, les exemples de projets et la documentation.

  • AK/Plugin/PluginServices.h – Classes d'aide pour la gestion des paramètres.
  • AK/Plugin/PluginBase.h – Interface de plugin de base.
  • AK/Plugin/NumericalParam.h – Manipulation des paramètres en utilisant l'ID numérique.
  • AK/WwiseAuthoringAPI/... – Pour construire une interface graphique personnalisée (facultatif).

Vous pouvez lire le officiel Documentation WWise SDK En outre, Audiokinetic fournit des plugins d'exemple (par exemple, "SampleFX" et "SampleSource") qui servent de points de départ excellents.

Prérequis pour le développement de plugins personnalisés

Pour réussir à construire un plugin Wwise personnalisé, vous avez besoin d'un ensemble spécifique de compétences et d'outils. Alors que l'article original énumère les bases, voici une liste de contrôle étendue et pratique:

  • C++ Compétences : Vous devez être à l'aise avec le C++ moderne (au moins C++14), y compris la gestion de la mémoire, la gestion en temps réel du tampon audio et le débogage. La connaissance du DSP (traitement numérique du signal) est très bénéfique mais peut être apprise à côté.
  • Connaissance du SDK WWise : Téléchargez la dernière version du SDK WWise (appariement à votre version WWise). Passez du temps à examiner la documentation et le code d'exemple avant de démarrer votre propre plugin.
  • Studio visuel : Le développement Windows utilise généralement Microsoft Visual Studio 2019 ou 2022. Les modèles de plugin WWise s'intègrent directement dans l'IDE. Pour macOS, Xcode est pris en charge mais moins commun pour le développement de plugin WWise.
  • Développement Environnement Mise en place : Vous devez configurer correctement les répertoires, les chemins de bibliothèque et les définitions de préprocesseur. Le SDK fournit un système de construction basé sur CMake, mais les solutions Visual Studio peuvent également être configurées manuellement.
  • Compte audiocinétique : Un compte gratuit vous donne accès aux téléchargements SDK, à la documentation et aux forums communautaires où vous pouvez poser des questions.
  • Launcher Wwise : Utilisez le lanceur Wwise pour gérer les versions Wwise et les SDK. Il peut également aider à créer un nouveau projet de plugin à partir d'un modèle (disponible dans les versions plus récentes).

Don-t ignore l'importance d'une configuration de test solide — vous aurez besoin d'un projet Wwise où vous pouvez charger votre plugin et le tester en temps réel avec un jeu ou une simulation autonome.

Compétences facultatives mais recommandées

  • Compréhension des formats audio (PCM, flotteurs, conversion de taux d'échantillonnage).
  • Connaissance de l'intégration du moteur de jeu (Unité, Unreal Engine) pour comprendre comment les plugins interagissent avec l'hôte.
  • Expérience avec le contrôle de version (Git) pour gérer le code plugin à travers les projets.
  • Connaissance de base de la programmation SIMD (SSE, AVX) pour l'optimisation des performances sur les processeurs modernes.

Étape par étape : Création d'un plugin Wwise personnalisé

Ci-dessous est une passerelle en profondeur pour construire un plugin à effet simple — un filtre passe-bas personnalisé avec un contrôle de résonance qui utilise un filtre IIR de deuxième ordre. Ceci illustrera le flux de travail général qui s'applique à tout type de plugin.

Étape 1: Mettre en place l'environnement de développement

D'abord, installez le SDK Wwise. Depuis le Launcher Wwise, allez dans l'onglet "SDKs" et téléchargez la version qui correspond à votre installation Wwise (par exemple, 2022.1.x). Dézippez le SDK à un emplacement de votre choix, comme . Puis ouvrez Visual Studio et créez un nouveau projet. Site web d'Audiokinetic (cherchez les « outils de plugin WWWise » ou « modèles de plugin WWWWise »).

Si vous utilisez le modèle, exécutez le script et suivez les instructions pour générer une solution Visual Studio avec la bonne structure. Si vous construisez à partir de zéro, vous devez configurer manuellement des répertoires pour et les chemins de bibliothèque appropriés pour (ou vc140, etc.) pour les configurations de Debug et de Release. Assurez-vous de configurer la bonne bibliothèque d'exécution: utilisez la DLL multi-threaded () pour les compilations de Release pour correspondre aux binaires propres de Wwise.

Étape 2: Créer la classe de greffons

Votre classe principale de plugins devrait hériter de (pour les plugins FX). Vous devez implémenter les méthodes virtuelles pures suivantes:

Dans la méthode , vous lancez le pointeur dans votre classe de paramètres personnalisée (voir Étape 3) et attribuez tout état interne (coefficients de filtre, lignes de retard). La méthode est l'endroit où se produit le DSP réel — il itère sur les canaux et les échantillons du tampon audio, applique votre algorithme et écrit la sortie dans le même tampon (ou un nouveau si spécifié).

Faites attention au format tampon : contient des données intercalées ou désintercalées selon la configuration. La méthode renvoie un pointeur au début des données d'échantillonnage d'un canal. Assurez-vous que votre algorithme gère à la fois le mono et le multicanal (jusqu'à 7.1) sans crosstalk de canal.

Étape 3: Définir les paramètres

Les paramètres sont contrôlés par une classe séparée qui hérite de . Vous définissez un ensemble d'ID de paramètre (enum) et puis implémentez et pour permettre à Wwise de lire/écrire des valeurs. Pour le filtre passe-bas, nous avons besoin de deux paramètres :

  • Fréquence de coupure (flott, portée 20 Hz – 20 kHz, par défaut 1 kHz)
  • Résonance (flott, plage de 0,0 – 1,0, par défaut 0,707)

Voici un extrait de classe de paramètre simplifié:

Dans la méthode , vous lisez ces paramètres et mettez à jour les coefficients de filtre en conséquence. Pour éviter que les changements de paramètre ne provoquent des clics, appliquer un lissage (p. ex. interpolation linéaire sur quelques échantillons).Une technique courante consiste à maintenir une valeur lissée qui se déplace vers la cible sur un temps de rampe configurable (typiquement 5-10 ms).

Étape 4: Mettre en œuvre l'algorithme DSP

Pour un filtre IIR à passe-bas de deuxième ordre, l'implémentation standard de forme directe 1 fonctionne bien. Gardez à l'esprit que l'audio en temps réel exige un code à latence basse : évitez les allocations dynamiques, utilisez des tableaux statiques pour les lignes de retard et préférez les mathématiques entières lorsque cela est approprié.

N'oubliez pas de gérer les cas de bords tels que les taux d'échantillonnage très bas (un upampling peut être nécessaire pour les fréquences de coupure au-dessus de Nyquist) et de réinitialiser les états du filtre lorsque le plugin est réinitialisé ou que les paramètres changent de façon discontinue.

Étape 5: Enregistrer et compiler le plugin

Chaque plugin doit être enregistré auprès du gestionnaire de plugins de Wwise. Dans votre fichier source plugin, ajoutez la macro d'enregistrement:

Compilez le projet en tant que DLL (configuration de la sortie). Assurez-vous que le binaire de sortie est placé dans les répertoires corrects pour la création de Wwise (par exemple, ) et pour l'exécution (par exemple, ). Si vous construisez pour plusieurs plateformes, créez des configurations séparées.

Étape 6: Essai à l'intérieur du système WWise

Lancez Wwise Authoring (l'éditeur de projet Wwise). Créez un nouveau Bus audio ou insérez un effet sonore. Dans l'onglet Effet, vous devriez voir votre plugin listé dans "Custom." Ajoutez-le à la chaîne de signal. Ajustez les paramètres dans l'éditeur de propriété. Si vous avez construit une interface graphique personnalisée, il apparaîtra. Jouez l'audio pour vérifier le traitement. Utilisez le profiler pour vérifier l'utilisation et la mémoire du processeur. Il est également sage de tester le plugin dans une intégration de jeu en direct (par exemple, Unité) pour s'assurer qu'il fonctionne dans des conditions réelles avec priorité et spatialisation sonores.

Meilleures pratiques pour le développement de plugins robustes

L'article original énumérait plusieurs bonnes pratiques. Ici, nous élargissons chacune avec un raisonnement concret et des conseils supplémentaires.

Optimiser pour une faible latence et une performance élevée

  • Utilisez l'arithmétique à point fixe lorsque c'est possible pour éviter les décrochages de pipelines à point flottant sur les processeurs mobiles.
  • Précalculer les coefficients et les mettre à jour uniquement lorsque les paramètres changent (p. ex. suivre un drapeau sale). Cela évite les maths redondants dans la boucle d'échantillon.
  • Utilisez les intrinsèques SSE/AVX pour le traitement SIMD sur des boucles d'échantillons en vrac pour gagner 2-4x vitesse sur les processeurs x86 modernes.
  • Tester avec des valeurs de paramètres extrêmes (coupe à Nyquist, résonance près de l'auto-oscillation) pour éviter les dénormalités ou les boucles infinies. Activer le mode flush-to-zero pour les nombres dénormals.

Assurer la compatibilité entre les versions WWise

  • Restez à jour avec les notes de sortie de WWise SDK. Chaque version principale introduit de nouvelles fonctionnalités et déprécie les anciennes.
  • Lien contre les bibliothèques d'exécution correctes (MD pour DLL multi-threaded). Les exécutions mal adaptées causent des accidents.
  • Si vous distribuez votre plugin, fournissez des DLLs distinctes pour chaque version WWise (par exemple, 2021.1, 2022.1). Utilisez le pour avertir les utilisateurs si un mauvais ajustement est détecté.

Documentez votre code avec soin

  • En plus des commentaires en ligne, écrire un LIRE qui explique l'algorithme, les plages de paramètres et comment intégrer le plugin dans un moteur de jeu.
  • Inclure des exemples de configurations de projet Wwise où le plugin excelle.
  • Utilisez les commentaires de type Doxygen pour les fichiers d'en-tête afin que les utilisateurs puissent générer de la documentation.

Tester abondamment dans différents environnements sonores

  • Tester avec les entrées mono, stéréo et multicanaux (5.1, 7.1). De nombreux plugins se brisent sur multicanal en raison de l'état spécifique du canal qui n'est pas séparé.
  • Simuler l'automatisation des paramètres à des taux élevés (p. ex. messages MIDI CC) pour éviter les problèmes audio.
  • Exécutez le profileur Wwise tout en soulignant le plugin avec de nombreuses instances (jusqu'à 64).

Pratiques exemplaires supplémentaires

  • Mettre en œuvre Gestion des préréglages — Wwise prend en charge l'enregistrement et le chargement des presets. Assurez-vous que votre plugin sérialise/désérialise correctement ses paramètres en utilisant et .
  • Poignée Dépassement élégamment. Lorsqu'il est contourné, le plugin doit passer l'audio sans modification avec un minimum de frais généraux.
  • Fournir Débogueurs: utilisez pour enregistrer les avertissements (par exemple, lorsque les paramètres sont hors de portée) mais désactivez-les dans les compilations de libération.

Sujets avancés : Extension des plugins personnalisés

Construire une interface graphique personnalisée

Pour un sentiment professionnel, vous pouvez créer une interface utilisateur qui apparaît dans l'environnement Wwise Authoring. Cela implique la construction d'un plugin UI DLL séparé qui communique avec votre DLL de traitement via l'interface . Vous pouvez utiliser le cadre d'interface utilisateur Wwise ou intégrer des contrôles Windows standard (Direct2D, WinForms) via un pont. WWise Auteur de la documentation API fournit des exemples de curseurs, de boutons et de graphiques.

Modulation des paramètres en temps réel

Wwise permet aux paramètres de jeu de moduler les paramètres du plugin via les RTPC (contrôles des paramètres en temps réel). Dans votre plugin, vous devez exposer les ID des paramètres et vous assurer qu'ils peuvent être mis à jour par tampon sans réinitialisation. Ceci est particulièrement puissant: vous pouvez cartographier une variable de jeu (p. ex., santé du joueur) à la coupure du filtre pour les retours audio.

Support multiplateforme

Votre plugin personnalisé peut avoir besoin de fonctionner sur PC, consoles (PS5, Xbox) et mobile. Le SDK WWise est spécifique à la plate-forme. Vous devrez compiler votre code pour chaque cible, gérer l'endianité, l'alignement de la mémoire et les intrinsèques du compilateur spécifique à la plate-forme. Utilisez les macros préprocesseurs () pour isoler le code de la plate-forme. Audiokinetic fournit des aides à l'abstraction de la plate-forme dans . Testez sur chaque cible tôt pour attraper les problèmes d'alignement.

Conception pour la performance en temps réel

Les performances sont critiques dans les plugins Wwise car ils s'exécutent à l'intérieur du fil de rendu audio. Tout retard ou pic peut causer des problèmes sonores. Voici des techniques spécifiques pour garder votre plugin efficace:

  • Allocation de mémoire : Allocate toute la mémoire pendant et jamais dans . Utilisez l'allocateur fourni () pour toutes les allocations liées au plugin.
  • Code sans branche: Évitez les branches conditionnelles dans les boucles d'échantillonnage. Utilisez des arithmétiques (p. ex., pince avec min/max) ou des tables de recherche au lieu de si-statements.
  • Pliage constant : Calculer tous les coefficients qui dépendent de la fréquence de l'échantillon et des paramètres fixes une fois dans ] et les mettre à jour uniquement lorsque les paramètres changent.
  • Localisation de la cache : Entreposez les états de filtre dans des tableaux contigus par canal pour maximiser les coups de cache. Évitez la poursuite des pointeurs.

Distribuer votre plugin

Une fois votre plugin stable, vous pouvez le paqueter pour distribution. La méthode standard est de créer un paquet Wwise Plugin (installateur). Utilisez l'outil Wwise Plugin Installer du SDK (ou un installateur personnalisé) qui place les DLL dans les dossiers corrects. Créez un fichier manifeste qui liste les versions du plugin ID, version et supporté Wwise. Vous pouvez vendre ou donner votre plugin sur des marchés comme la Communauté Audiokinétique ou les magasins de plugins audio tiers. Fournissez des instructions claires d'installation et un accord de licence. Envisager d'offrir à la fois un essai gratuit (avec limitations) et une version entièrement payée.

Exemple réel-monde: Plugin de source granulaire personnalisé

Pour illustrer la puissance des plugins personnalisés, considérez un plugin source qui génère des nuages granulaires à partir d'échantillons enregistrés. Ce plugin pourrait charger un petit clip audio et utiliser des positions de lecture aléatoires, des tailles de grains et des emplacements pour créer des textures évolutives. Dans un jeu, cela pourrait être utilisé pour le vent ambiant, des sorts magiques ou des transitions musicales dynamiques. Pour construire ce plugin, il faut un plugin source (héritière de ), un paramètre pour le taux de grains, la densité et la randomisation, et une gestion de mémoire soigneuse pour éviter de sauter aux limites des grains.

Dépannage de problèmes communs

  • Plugin non apparaissant dans Wwise: Vérifiez que la DLL est construite pour la bonne plate-forme (x64) et placée dans le dossier correct. Vérifiez que l'ID du plugin dans la macro d'enregistrement correspond à l'ID dans le projet Wwise. Assurez-vous également que le plugin est compilé avec les paramètres de traitement d'exception C++ corrects (exceptions C++ désactivées).
  • Déformation ou panne audio: Activer le débogage dans le développement. Causes probables : état du filtre non initialisé, dépassement du tampon ou division par zéro. Utilisez le profileur WWise pour détecter une utilisation élevée du processeur.
  • Mises à jour des paramètres cause clics: Appliquer la rampe (plus de 5-10 ms) lorsque les coefficients changent. Utiliser un filtre à variable d'état pour gérer la modulation rapide en douceur.
  • Fuites de mémoire: Toujours libérer la mémoire attribuée dans en utilisant le même allocateur (). N'utilisez jamais la norme . Utilisez les enveloppes RAII pour le nettoyage automatique.
  • Plugin fonctionne dans Wwise Authoring mais pas dans le jeu: Le plugin d'exécution DLL doit être présent dans le répertoire exécutable du jeu ou dans le dossier propre à la plate-forme appropriée. Vérifiez également que le binaire du plugin est compilé pour la même architecture (x86 vs x64) que le jeu.

Conclusion

La création de plugins Wwise personnalisés ouvre des possibilités infinies pour les concepteurs de sons et les programmeurs audio. La capacité de mettre en œuvre des algorithmes DSP spécialisés, de générer du matériel source unique et de s'intégrer étroitement à la logique de jeu donne à votre audio un avantage distinctif. Bien que le voyage du concept à un plugin prêt à la production nécessite un codage discipliné, des tests approfondis et une connaissance du SDK Wwise, les résultats valent bien l'effort. Forums des communautés audiokinétiques sont une ressource précieuse pour le dépannage et le partage d'idées. Avec les conseils fournis dans cet article, vous êtes prêt à construire un traitement audio qui est vraiment unique à votre projet.