Manuel du propriétaire | Native Instruments Reaktor 5 Manuel utilisateur
Ajouter à Mes manuels224 Des pages
▼
Scroll to page 2
of
224
REAKTOR CORE Tutoriel / Manuel Utilisateur Les informations contenues dans ce document peuvent être modifiées à tout moment sans préavis et n’engagent pas la responsabilité de Native Instruments Software Synthesis GmbH. Le Logiciel décrit dans ce document est soumis à l’acceptation d’une Licence d’Utilisation et ne doit pas être copié sur d’autres supports. Aucune partie de ce manuel ne peut être copiée, reproduite, transférée ou enregistrée, sous quelque forme que ce soit et pour quelque usage que ce soit, sans l’accord écrit explicite de Native Instruments Software Synthesis GmbH. Tous les noms de produits et d’entreprises sont des marques déposées par leurs propriétaires respectifs. De plus, si vous lisez ceci, cela signifie que vous avez préféré acheter le logiciel plutôt que de le voler. C’est grâce aux gens comme vous que nous pouvons continuer à créer de formidables outils et à les mettre à jour . Nous vous en remercions chaleureusement. Manuel d’utilisation écrit par: Native Instruments Software Synthesis et Len Sasso Traduction : Nicolas Sidi (nicolas.sidi@polytechnique.org) Remerciements spéciaux à l’équipe de bêta-testeurs, dont l’aide nous fut précieuse non seulement pour trouver et corriger les bogues, mais aussi pour rendre ce produit encore meilleur. © Native Instruments Software Synthesis GmbH, 2005. Tous droits réservés. REAKTOR, REAKTOR 5 et REAKTOR CORE sont des marques de Native Instruments Software Synthesis. Germany USA Native Instruments GmbH Schlesische Str. 28 D-10997 Berlin Germany info@native-instruments.de www.native-instruments.de Native Instruments USA, Inc. 5631 A Hollywood Boulevard Los Angeles, CA 90028 USA info@native-instruments.com www.native-instruments.com Table des matières 1. Premiers pas avec Reaktor Core ........................................................... 11 1.1. Qu’est-ce que Reaktor Core ? ...................................................11 1.2. Utilisation des cellules core .....................................................12 1.3. Utilisation des cellules core dans un exemple réel ......................15 1.4. Édition basique des cellules core ..............................................17 2. Pénétrer dans l’environnement Reaktor Core .........................................23 2.1. Cellules core évènement et audio ............................................. 23 2.2. Création de votre première cellule core..................................... 25 2.3. Les signaux audio et les signaux de contrôle ..............................37 2.5. Utiliser l’audio comme signal de contrôle...................................51 2.6. Les signaux évènements ......................................................... 53 2.7. Les signaux logiques .............................................................. 57 3. Fondements de Reaktor Core: le modèle du signal core ..........................60 3.1. Les valeurs ........................................................................... 60 3.2. Les évènements .................................................................... 60 3.3. Évènements simultanés ........................................................... 63 3.4. L’ordre de traitement .............................................................. 65 3.5. Retour aux cellules core évènements........................................ 66 4. Les structures avec état interne ...........................................................72 4.1. Les signaux d’horloge ..............................................................72 4.2. Les Object Bus Connections (OBC)........................................... 73 4.3. Initialisation .......................................................................... 77 4.4. Construire un accumulateur d’évènements ................................ 79 4.5. Le mélange d’évènements .......................................................81 4.6. L’accumulateur d’évènements avec reset et initialisation ............. 83 4.7. Réparons le modeleur d’évènements ........................................ 89 5. Le traitement de l’audio en détail ..........................................................92 5.1. Les signaux audio ................................................................... 92 5.2. Le bus d’horloge du taux d’échantillonnage ............................... 94 5.3. Réinjection d’une connexion ................................................... 95 5.4. Réinjection et macros ............................................................ 99 5.5. Les valeurs dénormales .........................................................103 5.6. Les autres mauvais nombres ..................................................108 5.7. Construction d’un filtre passe-bas à 1 pôle ..............................109 6. Le traitement conditionnel .................................................................. 112 6.1. Le routage des évènements....................................................112 REAKTOR CORE – III 6.2. Construction d’un limiteur de signal ........................................ 115 6.3. Construction d’un oscillateur en dents de scie simple ............... 116 7. Les autres types de signaux ................................................................ 118 7.1. Les signaux flottants .............................................................118 7.2. Les signaux entiers ...............................................................120 7.3. Construction d’un compteur d’évènements ...............................123 7.4. Building a rising edge counter macro .......................................124 8. Les tableaux ...................................................................................... 128 8.1. Introduction aux tableaux ......................................................128 8.2. Construction d’un détecteur de signal audio ............................131 8.3. Construction d’un délai .........................................................138 8.4. Les tables ...........................................................................144 9. Construction de structures optimisées ................................................149 9.1. Les Latches et les macros à modulation ..................................149 9.2. Routage et mélange ...............................................................150 9.3. Les opérations numériques ....................................................151 9.4. Conversions entre flottants et entiers ......................................152 Annexe A. Interface utilisateur de Reaktor Core ......................................154 A.1. Les cellules core....................................................................154 A.2. Les macros et modules core ..................................................154 A.3. Les ports core......................................................................155 A.4. Modification de la structure core ............................................155 Annexe B. Le concept de Reaktor Core .................................................... 156 B.1. Les signaux et les évènements ...............................................156 B.2. L’initialisation.......................................................................157 B.3. Les connexions OBC .............................................................157 B.4. Le routage ...........................................................................157 B.5. Le “latching” .......................................................................157 B.6. Les horloges ........................................................................158 Annexe C. Les ports des macros core...................................................... 158 C.1. In .......................................................................................158 C.2. Out .....................................................................................158 C.3. Latch (entrée) ......................................................................159 C.4. Latch (sortie) .......................................................................159 C.5. Bool C (entrée) ....................................................................159 C.6. Bool C (sortie) .....................................................................159 Annexe D. Les ports des cellules core ..................................................... 160 D.1. In (mode audio)....................................................................160 IV – REAKTOR CORE D.2. Out (mode audio) .................................................................160 D.3. In (mode évènement) ............................................................160 D.4. Out (mode évènement) .........................................................160 Annexe E. Les bus intégrés ..................................................................... 161 E.1. SR.C ...................................................................................161 E.2. SR.R ...................................................................................161 Annexe F. Les modules d’usine ................................................................ 161 F.1. Const ...................................................................................161 F.2. Math > + .............................................................................162 F.3. Math > - ..............................................................................162 F.4. Math > * ..............................................................................162 F.5. Math > / ..............................................................................162 F.6. Math > |x| ............................................................................163 F.7. Math > –x .............................................................................163 F.8. Math > DN Cancel ................................................................163 F.9. Math > ~log .........................................................................163 F.10. Math > ~exp .......................................................................164 F.11. Bit > Bit AND .....................................................................164 F.12. Bit > Bit OR .......................................................................164 F.13. Bit > Bit XOR .....................................................................164 F.15. Bit > Bit << ........................................................................165 F.16. Bit > Bit >> ........................................................................165 F.17. Flow > Router .....................................................................165 F.18. Flow > Compare ..................................................................166 F.19. Flow > Compare Sign ...........................................................166 F.20. Flow > ES Ctl .....................................................................167 F.21. Flow > ~BoolCtl ..................................................................167 F.22. Flow > Merge .....................................................................167 F.23. Flow > EvtMerge .................................................................167 F.24. Memory > Read ..................................................................168 F.25. Memory > Write ..................................................................168 F.26. Memory > R/W Order ..........................................................168 F.27. Memory > Array ..................................................................169 F.28. Memory > Size [ ] ...............................................................169 F.29. Memory > Index .................................................................169 F.30. Memory > Table ..................................................................170 F.31. Macro ................................................................................170 Annexe G. Les macros expertes .............................................................. 171 G.1. Clipping > Clip Max / IClip Max ..............................................171 REAKTOR CORE – V G.2. Clipping > Clip Min / IClip Min ...............................................171 G.3. Clipping > Clip MinMax / IClipMinMax ....................................171 G.4. Math > 1 div x .....................................................................171 G.5. Math > 1 wrap .....................................................................171 G.6. Math > Imod .......................................................................172 G.7. Math > Max / IMax ...............................................................172 G.8. Math > Min / IMin ................................................................172 G.9. Math > round.......................................................................172 G.10. Math > sign +- ...................................................................172 G.11. Math > sqrt (>0) ................................................................173 G.13. Math > x(>0)^y .................................................................173 G.14. Math > x^2 / x^3 / x^4 .......................................................173 G.15. Math > Chain Add / Chain Mult ............................................173 G.16. Math > Trig-Hyp > 2 pi wrap ................................................173 G.17. Math > Trig-Hyp > arcsin / arccos / arctan ............................. 174 G.18. Math > Trig-Hyp > sin / cos / tan .......................................... 174 G.19. Math > Trig-Hyp > sin –pi..pi / cos –pi..pi / tan –pi..pi ............ 174 G.20. Math > Trig-Hyp > tan –pi4..pi4 .......................................... 174 G.21. Math > Trig-Hyp > sinh / cosh / tanh .................................... 174 G.22. Memory > Latch / ILatch..................................................... 174 G.23. Memory > z^-1 / z^-1 ndc ...................................................175 G.24. Memory > Read [] ..............................................................175 G.25. Memory > Write [] ..............................................................175 G.26. Modulation > x + a / Integer > Ix + a ....................................176 G.27. Modulation > x * a / Integer > Ix * a .....................................176 G.28. Modulation > x – a / Integer > Ix – a .....................................176 G.29. Modulation > a – x / Integer > Ia – x .....................................176 G.30. Modulation > x / a ..............................................................176 G.31. Modulation > a / x ..............................................................177 G.32. Modulation > xa + y............................................................177 Annexe H. Les macros standard .............................................................. 177 H.1. Audio Mix-Amp > Amount .....................................................177 H.2. Audio Mix-Amp > Amp Mod ..................................................177 H.3. Audio Mix-Amp > Audio Mix ..................................................178 H.4. Audio Mix-Amp > Audio Relay ...............................................178 H.5. Audio Mix-Amp > Chain (amount) ..........................................178 H.6. Audio Mix-Amp > Chain (dB) .................................................179 H.7. Audio Mix-Amp > Gain (dB) ...................................................179 H.8. Audio Mix-Amp > Invert ........................................................179 H.9. Audio Mix-Amp > Mixer 2 … 4 ..............................................179 VI – REAKTOR CORE H.10. H.11. H.13. H.14. H.15. H.16. H.17. H.18. H.19. H.20. H.21. H.22. H.23. H.24. H.25. H.26. H.27. H.28. H.29. H.30. H.31. H.32. H.33. H.34. H.35. H.36. H.37. H.38. H.39. H.40. H.41. H.42. H.43. H.44. H.45. H.46. H.47. H.48. H.49. H.50. Audio Mix-Amp > Pan ........................................................ 180 Audio Mix-Amp > Ring-Amp Mod ........................................ 180 Audio Mix-Amp > Stereo Mixer 2 … 4 ..................................181 Audio Mix-Amp > VCA .........................................................181 Audio Mix-Amp > XFade (lin) ...............................................181 Audio Mix-Amp > XFade (par) ..............................................182 Audio Shaper > 1+2+3 Shaper .............................................182 Audio Shaper > 3-1-2 Shaper ..............................................182 Audio Shaper > Broken Par Sat ........................................... 183 Audio Shaper > Hyperbol Sat ............................................. 183 Audio Shaper > Parabol Sat ............................................... 183 Audio Shaper > Sine Shaper 4 / 8 ....................................... 184 Control > Ctl Amount ........................................................ 184 Control > Ctl Amp Mod ...................................................... 184 Control > Ctl Bi2Uni .......................................................... 184 Control > Ctl Chain ............................................................185 Control > Ctl Invert .............................................................185 Control > Ctl Mix ...............................................................185 Control > Ctl Mixer 2 ..........................................................185 Control > Ctl Pan .............................................................. 186 Control > Ctl Relay ............................................................ 186 Control > Ctl XFade ........................................................... 186 Control > Par Ctl Shaper .................................................... 186 Convert > dB2AF ...............................................................187 Convert > dP2FF ...............................................................187 Convert > logT2sec ............................................................187 Convert > ms2Hz ...............................................................187 Convert > ms2sec ............................................................. 188 Convert > P2F .................................................................. 188 Convert > sec2Hz ............................................................. 188 Delay > 2 / 4 Tap Delay 4p ................................................. 188 Delay > Delay 1p / 2p / 4p ................................................. 188 Delay > Diff Delay 1p / 2p / 4p ............................................189 Envelope > ADSR ..............................................................189 Envelope > Env Follower .....................................................190 Envelope > Peak Detector ...................................................190 EQ > 6dB LP/HP EQ ...........................................................190 EQ > 6dB LowShelf EQ ......................................................191 EQ > 6dB HighShelf EQ ......................................................191 EQ > Peak EQ ...................................................................191 REAKTOR CORE – VII H.51. H.52. H.53. H.54. H.55. H.56. H.57. H.58. H.59. H.60. H.61. H.62. H.63. H.64. H.65. H.66. H.67. H.68. H.69. H.70. H.71. H.72. H.74. H.75. H.76. H.77. H.78. H.79. H.80. H.81. H.82. H.83. H.84. H.85. H.86. H.87. H.88. H.89. H.90. H.91. EQ > Static Filter > 1-pole static HP ....................................191 EQ > Static Filter > 1-pole static HS ....................................192 EQ > Static Filter > 1-pole static LP .....................................192 EQ > Static Filter > 1-pole static LS .....................................192 EQ > Static Filter > 2-pole static AP ....................................192 EQ > Static Filter > 2-pole static BP ....................................192 EQ > Static Filter > 2-pole static BP1 ...................................193 EQ > Static Filter > 2-pole static HP ....................................193 EQ > Static Filter > 2-pole static HS ....................................193 EQ > Static Filter > 2-pole static LP.....................................193 EQ > Static Filter > 2-pole static LS .....................................194 EQ > Static Filter > 2-pole static N ......................................194 EQ > Static Filter > 2-pole static Pk .....................................194 EQ > Static Filter > Integrator .............................................194 Event Processing > Accumulator ..........................................195 Event Processing > Clk Div ..................................................195 Event Processing > Clk Gen .................................................195 Event Processing > Clk Rate ................................................195 Event Processing > Counter .................................................196 Event Processing > Ctl2Gate ...............................................196 Event Processing > Dup Flt / IDup Flt ...................................196 Event Processing > Impulse .................................................196 Event Processing > Separator / ISeparator .............................197 Event Processing > Thld Crossing .........................................197 Event Processing > Value / IValue .........................................197 LFO > MultiWave LFO .........................................................197 LFO > Par LFO ..................................................................198 LFO > Random LFO ............................................................198 LFO > Rect LFO ................................................................198 LFO > Saw(down) LFO ........................................................198 LFO > Saw(up) LFO ...........................................................199 LFO > Sine LFO .................................................................199 LFO > Tri LFO ...................................................................199 Logic > AND .....................................................................199 Logic > Flip Flop............................................................... 200 Logic > Gate2L ................................................................. 200 Logic > GT / IGT ............................................................... 200 Logic > EQ ....................................................................... 200 Logic > GE ....................................................................... 200 Logic > L2Clock ................................................................ 200 VIII – REAKTOR CORE H.92. Logic > L2Gate ..................................................................201 H.94. Logic > OR ........................................................................201 H.95. Logic > XOR ......................................................................201 H.97. Oscillators > 4-Wave Mst .................................................... 202 H.98. Oscillators > 4-Wave Slv .................................................... 202 H.99. Oscillators > Binary Noise .................................................. 202 H.100. Oscillators > Digital Noise ................................................ 203 H.101. Oscillators > FM Op ......................................................... 203 H.102. Oscillators > Formant Osc ................................................ 203 H.103. Oscillators > MultiWave Osc.............................................. 203 H.104. Oscillators > Par Osc ....................................................... 204 H.105. Oscillators > Quad Osc ..................................................... 204 H.106. Oscillators > Sin Osc ....................................................... 204 H.107. Oscillators > Sub Osc 4 .................................................... 204 H.108. VCF > 2 Pole SV ............................................................. 204 H.109. VCF > 2 Pole SV C .......................................................... 205 H.110. VCF > 2 Pole SV (x3) S .................................................... 205 H.111. VCF > 2 Pole SV T (S) ...................................................... 205 H.112. VCF > Diode Ladder ......................................................... 206 H.113. VCF > D/T Ladder ........................................................... 206 H.114. VCF > Ladder x3 ............................................................. 206 Annexe I. Core cell library ......................................................................208 I.1. Audio Shaper > 3-1-2 Shaper ................................................. 208 I.2. Audio Shaper > Broken Par Sat .............................................. 208 I.3. Audio Shaper > Hyperbol Sat................................................. 208 I.4. Audio Shaper > Parabol Sat................................................... 209 I.5. Audio Shaper > Sine Shaper 4/8 ............................................ 209 I.6. Control > ADSR ................................................................... 209 I.7. Control > Env Follower............................................................210 I.8. Control > Flip Flop ................................................................210 I.9. Control > MultiWave LFO ........................................................211 I.10. Control > Par Ctl Shaper.......................................................211 I.11. Control > Schmitt Trigger ......................................................211 I.12. Control > Sine LFO ..............................................................212 I.13. Delay > 2/4 Tap Delay 4p .....................................................212 I.14. Delay > Delay 4p .................................................................212 I.15. Delay > Diff Delay 4p ...........................................................212 I.16. EQ > 6dB LP/HP EQ ............................................................213 I.17. EQ > HighShelf EQ ...............................................................213 I.18. EQ > LowShelf EQ ...............................................................213 REAKTOR CORE – IX I.19. I.20. I.21. I.22. I.23. I.24. I.25. I.26. I.27. I.28. I.29. I.30. I.31. I.32. I.33. I.34. I.35. I.36. I.37. I.38. I.39. I.40. I.41. I.42. I.43. I.44. I.45. I.46. I.47. EQ > Peak EQ .....................................................................213 EQ > Static Filter > 1-pole static HP .....................................214 EQ > Static Filter > 1-pole static HS ......................................214 EQ > Static Filter > 1-pole static LP ......................................214 EQ > Static Filter > 1-pole static LS ......................................214 EQ > Static Filter > 2-pole static AP ......................................215 EQ > Static Filter > 2-pole static BP......................................215 EQ > Static Filter > 2-pole static BP1 ....................................215 EQ > Static Filter > 2-pole static HP ......................................215 EQ > Static Filter > 2-pole static HS .....................................216 EQ > Static Filter > 2-pole static LP ......................................216 EQ > Static Filter > 2-pole static LS ......................................216 EQ > Static Filter > 2-pole static N........................................216 EQ > Static Filter > 2-pole static Pk ......................................217 Oscillator > 4-Wave Mst .......................................................217 Oscillator > 4-Wave Slv ........................................................217 Oscillator > Digital Noise ......................................................218 Oscillator > FM Op ..............................................................218 Oscillator > Formant Osc ......................................................218 Oscillator > Impulse ............................................................219 Oscillator > MultiWave Osc ...................................................219 Oscillator > Quad Osc ..........................................................219 Oscillator > Sub Osc ........................................................... 220 VCF > 2 Pole SV C ............................................................. 220 VCF > 2 Pole SV T.............................................................. 220 VCF > 2 Pole SV x3 S ..........................................................221 VCF > Diode Ladder ............................................................221 VCF > D/T Ladder .............................................................. 222 VCF > Ladder x3................................................................. 222 Index ......................................................................................................223 X – REAKTOR CORE 1. Premiers pas avec Reaktor Core 1.1. Qu’est-ce que Reaktor Core ? Reaktor Core Reaktor Core est une nouvelle couche logicielle de fonctionnalités de Reaktor avec un nouvel ensemble de fonctions. Comme il y a déjà un ancien niveau de fonctionnalités, à partir de maintenant nous appellerons ces deux niveaux respectivement niveau core (noyau en anglais) et niveau primaire. De plus, lorsque nous parlerons de “structure de niveau primaire”, nous entendrons par là la structure interne d’un instrument ou d’une macro, mais pas celle d’un ensemble. Les fonctions de Reaktor Core ne sont pas directement compatibles avec celles du niveau primaire de Reaktor, une interface est nécessaire entre les deux. Cette interface est constituée par les cellules core. Les cellules core se situent dans les structures du niveau primaire, ressemblant et se comportant de façon similaire aux autres modules du niveau primaire. Voici un exemple de structure, utilisant une cellule core HighShelf EQ, qui est différente de la version habituelle du niveau primaire dans sa façon de répondre aux contrôles de fréquence et d’amplification: À l’intérieur des cellules core se trouvent des structures Reaktor Core, qui constituent un moyen efficace d’implémenter des fonctionnalités personnalisées de traitement du signal (ou “DSP”) de bas niveau, et permettent aussi de construire des structures de traitement du signal à plus grande échelle à partir de ces mêmes fonctionnalités. Ces structures seront étudiées plus loin dans le texte. Bien que l’une des principales caractéristiques de Reaktor Core soit de pouvoir construire ces structures de DSP de bas niveau, elles ne se limitent pas à cela. Si vous n‘êtes pas un expert en traitement du signal, nous vous avons facilité le travail en créant une librairie de modules que vous pouvez connecter dans les structures core de la même façon qu‘au niveau primaire, et une librairie REAKTOR CORE – 11 de cellules core que vous pouvez immédiatement utiliser dans les structures du niveau primaire. À dire vrai, chez Native Instruments, nous n’avons plus vraiment envie de créer des milliers de nouveaux modules de niveau primaire pour les nouvelles versions de Reaktor. Nous préférons les construire en utilisant notre nouvelle technologie Reaktor Core et les livrer sous forme de cellules core. Vous trouverez déjà un ensemble de nouveaux filtres, enveloppes, effets, etc., dans la librairie de cellules core. 1.2. Utilisation des cellules core La librairie de cellules core est accessible depuis les structures du niveau primaire via un clic droit sur le fond de l’écran, puis en choisissant le sousmenu Core Cell: Comme vous pouvez le voir, différents types de cellules core peuvent être utilisés comme des modules classiques de niveau primaire. Une limitation importante des cellules core est que vous ne pouvez pas les utiliser à l’intérieur des boucles d’évènements. Toute boucle d’évènement traversant une cellule core sera boquée par Reaktor. Vous avez aussi la possibilité d’insérer des cellules core qui ne sont pas dans la librairie. Pour ce faire, utilisez la commande Load… du même menu Core Cell: 12 – REAKTOR CORE Avant de pouvoir charger des fichiers de cellules core, il vous sauvegarder ces cellules core. Voici comment faire: effectuez un clic droit sur une cellule core et sélectionnez Save Core Cell As: Vous pouvez également placer vos propres cellules core dans le menu pour éviter d’utiliser la commande Load. Pour ce faire, placez-les dans le sousdossier “Core Cells” de votre dossier utilisateur. Encore mieux: mettez-les non pas directement dans le dossier “Core Cells” mais dans des sous-dossiers de votre crû. Voici un exemple de ce type d’organisation: REAKTOR CORE – 13 Dans cet exemple, “My Documents\Reaktor 5” est le dossier utilisateur. Sur votre ordinateur, il peut porter un autre nom, en fonction du choix que vous avez effectué lors de l’installation ou dans les préférences de Reaktor. Le dossier “Core Cells” se trouve dans ce dossier. S’il n’existe pas, créez-le manuellement. Dans ce dossier, nous en observons trois autres: “Effects”, “Filters” et “Oscillators”. À l’intérieur de ces dossiers se trouvent les fichiers des cellules core qui seront affichées dans la partie utilisateur du menu Core Cell: 14 – REAKTOR CORE Le contenu du menu est scanné lors du démarrage de Reaktor. Si vous ajoutez de nouveaux fichiers dans ces dossiers, vous devez redémarrer Reaktor pour qu’il les prenne en compte. Les dossiers vides ne sont pas affichés dans le menu, ils doivent contenir des fichiers pour être affichés. Vous ne devez en aucun cas placer vos propres fichiers dans la librairie système. Le dossier de la librairie système peut être modifié voire complètement effacé lors des mises à jour, et vos fichiers seraient alors perdus! La librairie utilisateur (en anglais user library) est l’endroit indiqué pour placer tout fichier non inclus dans l’application elle-même. 1.3. Utilisation des cellules core dans un exemple réel Nous allons prendre ici un instrument Reaktor construit uniquement avec des modules de niveau primaire et nous allons le modifier en y plaçant quelques cellules core. Dans le dossier “Core Tutorial Examples” du dossier d’installation de Reaktor, trouvez l’ensemble One Osc.ens et ouvrez-le. Cet ensemble est constitué d’un seul instrument ayant la structure interne suivante: Comme vous pouvez le constater, il s’agit d’un synthétiseur soustractif très simple doté d’un oscillateur, d’un filtre et d’une enveloppe. Nous allons remplacer l’oscillateur par un autre, plus puissant. Faites un clic droit sur le fond et sélectionnez Core Cell > Oscillator > MultiWave Osc: REAKTOR CORE – 15 La caractéristique la plus importante de cet oscillateur est qu’il fournit simultanément plusieurs formes d’ondes analogues calées en phase. Nous souhaitons utiliser leur mélange en lieu et place d’un simple oscillateur en dents de scie. Fort heureusement, il existe déjà un mixeur accessible via Insert Macro > Classic Modular > 02 Mixer Amp > Mixer – Simple – Mono: Connectons maintenant ensemble le mixeur et l’oscillateur et remplaçons l’oscillateur en dents de scie par leur combinaison: Passez en vue panel. Vous pouvez maintenant utiliser les quatre potentiomètres du mixeur pour modifier le mélange des formes d’onde. Modifions encore l‘instrument: ajoutons-lui un effet de chorus basé sur Reaktor Core. Nous écrivons “basé sur Reaktor Core” parce que, même si le chorus lui-même est construit en tant que cellule core, la partie contenant les contrôles du panneau de ce chorus est encore construite avec les fonctions du niveau primaire. Ceci est dû au fait que les structures Reaktor Core ne peuvent pas définir leurs propres panneaux de contrôles: ces panneaux doivent être construits au niveau primaire. 16 – REAKTOR CORE Sélectionnez Insert Macro > RX Based > Chorus > SE IV S et insérez-le après le module Voice Combiner: Si vous jetez un œil à l’intérieur du chorus, vous verrez la cellule core du chorus et les contrôles du panneau: 1.4. Édition basique des cellules core Penchons-nous maintenant sur l‘édition des cellules core. Nous allons commencer avec quelque chose de simple, comme la modification d’une cellule core existante pour l’adapter à vos besoins. Tout d’abord, double-cliquez sur le MultiWave Osc pour pénétrer à l’intérieur: Entrées Normal Sorties REAKTOR CORE – 17 Ce que vous voyez maintenant est une structure Reaktor Core. Les trois zones séparées par des lignes verticales délimitent trois types de modules: les modules d’entrée (à gauche), les modules de sortie (à droite) et les modules normaux (au centre). Les entrées et les sorties peuvent être déplacées uniquement verticalement, et leur ordre correspond à l’ordre dans lequel elles apparaissent à l’extérieur de la structure. Les modules normaux (au centre donc) peuvent être déplacés dans n’importe quelle direction. Par exemple, placez l’entrée FM sous l’entrée PW: Vous pouvez maintenant double-cliquer sur le fond pour remonter à la structure extérieure du niveau primaire et observer la modification de l’ordre des ports d’entrée. Revenons au niveau core et n’oublions pas de remettre les ports d’entrée dans l’ordre originel: Comme vous l’avez probablement déjà remarqué, si vous déplacez les modules, les trois parties de la structure core peuvent s’agrandir afin de toujours englober tous les modules. Cependant, elles ne se réduisent pas automatiquement, ce qui peut les conduire à devenir beaucoup, beaucoup trop larges: 18 – REAKTOR CORE Vous pouvez les réduire via un clic droit sur le fond et en sélectionnant la commande Compact Board: Maintenant que nous savons déplacer les composants d’une cellule core, et même réarranger l’ordre de ses ports d’entrée et de sortie, essayons-nous à quelques autres manipulations. Pour une cellule core qui dispose de sorties audio, il est possible de commuter le type de ses entrées entre audio et évènement (vous trouverez une explication détaillée de leur différence plus loin dans le texte). Dans l’exemple ci-dessus, nous avons utilisé un module MulitWave Osc qui dispose d’entrées et de sorties audio. Mais dans notre cas, nous n’avons pas vraiment besoin d’entrées audio, puisque le seul élément connecté à l’oscillateur est le potentiomètre de pitch (hauteur tonale). Ne serait-il pas plus économique (en ressources REAKTOR CORE – 19 processeur) d’utiliser au moins partiellement des évènements ? La réponse est évidemment “Oui !”, aussi allons-nous le faire de ce pas. Nous vous suggérons de changer au moins les entrées P et PM pour les passer en mode évènement. Cela devrait permettre la plus grande économie en puissance processeur. Double-cliquez sur le module d’entrée P pour ouvrir sa fenêtre de propriétés: Double-cliquez ici Ouvrez la page de fonction de la fenêtre de propriétés (si nécessaire en cliquant sur le bouton ). Vous devriez maintenant voir s‘afficher la propriété de mode de signal (Signal Mode): Réglez-la sur event (évènement en anglais). Remarquez comment le gros point à gauche du module d’entrée passe du noir au rouge pour indiquer que l’entrée est désormais en mode évènement (c’est plus visible lorsque le module n’est pas sélectionné, cliquez quelque part ailleurs pour le désélectionner): Le bouton devient rouge Cliquez maintenant sur l’entrée PM et passez-la aussi en mode évènement. Si vous le souhaitez, vous pouvez aussi passer les deux entrées restantes en mode évènement. Après avoir fini, double-cliquez sur le fond de la structure 20 – REAKTOR CORE pour revenir au niveau primaire et observez la nouvelle couleur rouge des ports et l’utilisation diminuée du processeur. Il est parfois absurde de commuter un port d‘un type à l‘autre. Par exemple, une entrée recevant véritablement un signal audio (contenant un vrai son, pas simplement un signal de contrôle tel qu‘une enveloppe calée sur le son) ne doit pas être commutée en mode évènement. Non seulement c’est absurde, mais de plus cela risque de ruiner le fonctionnement du module. Un autre cas absurde: lorsque vous avez une entrée de type évènement vraiment sensible aux évènements, p.ex. une entrée de contrôle sur une enveloppe (comme les entrées Gate des enveloppes du niveau primaire de Reaktor). Si vous essayez de les passer en mode audio, elles ne fonctionneront plus correctement. Parallèlement aux cas où il est évident que la commutation du type de port est absurde, il peut y avoir des cas dans lesquels elle est autorisée mais les modules refusent alors de fonctionner. Cependant, ces cas sont normalement très rares, ou bien c’est qu’une une erreur s’est glissée dans l’implémentation du module. Généralement, la commutation du type de port fonctionne. Nous vous proposons la règle de commutation suivante: Dans une cellule core bien conçue, une entrée de contrôle audio peut être commutée en évènement sans aucun problème. Une entrée de type évènement peut être commutée en audio seulement si elle n’a pas de fonction de commande. Pour économiser du processeur, vous pouvez aussi déconnecter les sorties audio dont vous n’avez pas besoin, désactivant ainsi les parties inutilisées de la structure Reaktor Core. Vous devez effectuer cette opération depuis l’intérieur de la structure – à l’extérieur, les connexions n’ont pas d’effet sur la désactivation des éléments de la structure core. Dans notre exemple, décidons que nous n’avons pas besoin des quatre sorties mais seulement de la dent de scie et du train d’impulsions. Nous pouvons aller dans dans le MultiWace Osc et déconnecter les sorties inutiles. La déconnexion est une opération très simple: il suffit de cliquer sur le port d’entrée REAKTOR CORE – 21 de la connexion, de déplacer la souris n’importe où sauf sur un port de sortie et de relâcher le bouton. Commençons avec la sortie “Tri” (pour “triangle”). Cliquez sur le port de la sortie “Tri” et déplacez la souris sur un endroit vide du fond de l’écran. Il y a un autre moyen de supprimer une connexion. Cliquez sur la connexion entre la sortie “sine” du MultiWave Osc et la sortie “Sin” de la cellule core, de façon à la sélectionner (elle change de couleur): Vous pouvez maintenant appuyer sur la touche Suppr de votre clavier pour supprimer la connexion: Après avoir supprimé les deux câbles, l’indicateur d’utilisation du processeur devrait descendre encore un peu. Et si vous changez d’avis et décidez de les reconnecter ? C’est tout aussi simple: cliquez sur l’entrée ou la sortie que vous souhaitez reconnecter, déplacez la souris sur le port opposé de la connexion et relâchez le bouton. Par exemple, cliquez sur la sortie “tri” du MultiWave Osc et déplacez la souris jusqu’au module de sortie “Tri”. La connexion est rétablie: 22 – REAKTOR CORE Bien sûr, les possiblités de modification des cellules core sont bien plus étendues que ce que nous venons de décrire. Vous en apprendrez beaucoup plus en continuant votre lecture. 2. Pénétrer dans l’environnement Reaktor Core 2.1. Cellules core évènement et audio Les cellules core existent en deux parfums: Évènement et Audio (en anglais Event et Audio). Les cellules core évènements ne peuvent recevoir en entrée que des signaux évènements du niveau primaire, et ne produisent en sortie que des signaux évènements du niveau primaire, en réponse aux premiers. Les cellules core audio peuvent recevoir en entrée des signaux évènements et audio, mais ne produisent en sortie que des signaux audio: Parfum Évènement Audio Entrées Sorties Évènements Évènements Évènements/ Audio Audio Sources d’Horloge Désactivées Activées Ainsi, les cellules audio permettent d’implémenter oscillateurs, filtres, enveloppes et autres effets, tandis que les cellules évènements ne servent qu’aux tâches de traitement des évènements. Les modules HighShelf EQ et MultiWave Osc que nous avons déjà vus sont des exemples de cellules core audio (elles ont des sorties audio). REAKTOR CORE – 23 Et voici un exemple de cellule core évènement: Ce module est un modeleur parabolique (en anglais “parabolic shaper”) pour les signaux de contrôle; il peut par exemple être utilisé pour le modelage de courbes de vélocité ou de signaux de LFO. Nous avons écrit ci-dessus que les cellules core évènements ne servent qu’aux tâches de traitement des évènements. Les sources d‘horloge de ces cellules étant désactivées dans ces cellules (cf. tableau ci-dessus), elles ne peuvent générer leurs propres évènements et ne peuvent donc servir à implémenter des modules comme des enveloppes ou des LFOs calés sur des évènements. Si vous souhaitez implémenter de tels modules, nous vous suggérons de prendre une cellule audio et de convertir sa sortie en évènements grâce à l’un des convertisseurs audio-évènement du niveau primaire: La structure ci-dessus utilise d’abord une cellule core audio implémentant une enveloppe ADSR, puis convertit sa sortie sous forme d’évènements pour moduler un oscillateur. 24 – REAKTOR CORE 2.2. Création de votre première cellule core Pour créer une nouvelle cellule core, faites un clic droit sur le fond de l’écran dans la structure du niveau primaire et sélectionnez Core Cell > New Audio ou (pour les cellules évènements) Core Cell > New Event: Nous allons construire une nouvelle cellule core à partir du modèle inclus dans le module One Osc.ens que vous avez déjà manipulé. Nous utiliserons la nouvelle version de cet ensemble (avec le nouvel oscillateur et le chorus) que nous avons construite précédemment, mais si vous ne l’avez pas sauvegardée, ne vous en faites pas, vous pouvez faire la même chose à partir du One Osc.ens original. Comme vous pouvez le constater dans cet ensemble, nous modulons l’entrée P du filtre, qui n’accepte que des signaux évènements. Nous n’utilisons pas la version FM du même filtre car d’une part elle se comporte moins bien aux fréquences de coupure élevées, et d’autre part l’échelle de modulation de l’entrée FM est linéaire, ce qui donne généralement de moins bons résultats musicaux pour une modulation par enveloppe (ce que l’on appelle habituellement – mais incorrectement – les “enveloppes lentes”): REAKTOR CORE – 25 Comme nous voulons moduler une entrée évènement, nous avons besoin de convertir l’enveloppe en signal évènement, ce qui est accompli par le convertisseur A/E. La vitesse de contrôle en résultant est relativement basse. Bien entendu, nous aurions pu utiliser un convertisseur fonctionnant à une vitesse plus élevée (et consommant plus de puissance processeur), mais au lieu de cela nous allons remplacer ce filtre par un autre que nous construirons sous forme de cellule core. Nous aurions pu aussi en prendre un directement dans la librairie existante de cellules core, mais nous n‘aurions pas le bonheur de fabriquer notre première structure Reaktor Core. Empruntons donc un chemin plus ardu. Commençons par créer une nouvelle cellule core audio en sélectionnant Core Cell > New Audio. Une cellule core audio vide apparaît: Double-cliquez dessus pour faire apparaître sa structure Reaktor Core interne, qui est… vide. Vous vous en rappelez sûrement, les trois zones sont (de gauche à droite) les entrées, les modules normaux et les sorties: Attention, nous allons maintenant insérer notre premier module dans une structure core! Effectuez un clic droit dans la zone “normale” (au centre donc) pour appeler le menu de création de modules: 26 – REAKTOR CORE Le premier sous-menu est nommé Built In Module et permet d’accéder aux modules d’usine inclus dans Reaktor Core, qui sont généralement conçus pour effectuer des tâches de très bas niveau, et dont nous discuterons plus loin. Le second sous-menu, appelé Expert Macro, contient les macros prévues pour être utilisées avec les modules de base pour les opérations de bas niveau. Donc oublions-les aussi pour l’instant. Le troisième sous-menu s’appelle Standard Macro et semble être celui qu’il nous faut: REAKTOR CORE – 27 La section VCF pourrait bien être la bonne, jetons-y un œil: Peut-être pourrions-nous utiliser le module Diode Ladder (Échelle de diodes) ? Allons-y: En fait, ce n’est peut-être pas la meilleure idée, car le son du Diode Ladder doit être vraiment différent de celui du module filtre de niveau primaire que nous voulons remplacer. L’échelle de diodes est un filtre avec au minimum 4 pôles (24 dB/octave) et celui que nous voulons remplacer a seulement 2 pôles (12 dB/octave). Supprimons donc ce Diode Ladder. Pour ce faire, vous avez deux options. La première est de faire un clic droit sur le module puis de choisir Delete Module: 28 – REAKTOR CORE La seconde est de le sélectionner en cliquant dessus, puis d’appuyer simplement sur la touche Suppr. Après avoir supprimé le Diode Ladder, insérons à la place un filtre 2 Pole SV C depuis le même menu: Celui-ci est bien un filtre à 2 pôles à variables d’état, semblable à celui que nous voulons remplacer (avec quelques différences tout de même, mais assez subtiles). L’important est que nous puissions moduler celui-ci avec de l’audio. Nous aurons bien sûr aussi besoin d’entrées et de sorties pour notre cellule core. Pour être exact, nous aurons probablement besoin d’une seule sortie: le signal LP (passe-bas). Pour créer cette sortie, effectuez un clic droit dans la zone de sortie (à droite): REAKTOR CORE – 29 Dans cette zone, vous ne pouvez créer qu’un type de module, donc sélectionnez-le. La structure ressemble maintenant à ceci: Double-cliquez sur le module de sortie pour ouvrir la fenêtre de propriétés (si elle n’est pas déjà ouverte). Saisissez “LP” dans le champ de nom (Label sur l’écran): Connectez maintenant la sortie LP du filtre au module de sortie: Passons aux entrées. La première entrée sera le signal audio d’entrée. Faites un clic droit sur le fond de l’écran dans la zone d’entrée et sélectionnez New > In: 30 – REAKTOR CORE L’entrée est automatiquement créée avec le bon mode –comme vous l‘indique le gros point noir, il s‘agit d‘une entrée audio. Vous pouvez la renommer “In” de la même façon que pour le module “LP”, puis la connecter à la première entrée du module filtre: Pour la deuxième entrée du module filtre Reaktor Core, les choses se corsent. Comme vous pouvez le voir, cette entrée est nommée “F”, pour “fréquence”. Si vous maintenez le bouton de la souris enfoncé sur cette entrée (assurezvous que le bouton est activé), vous voyez apparaître le texte d’info “Cutoff frequency (Hz)” (“Fréquence de coupure (Hz)”): Nous savons que la fréquence de coupure de notre module filtre du niveau primaire est contrôlée par une entrée appelée “P” et utilise une échelle de demi-tons, comme vous pouvez l’observer dans le texte d’info de l’entrée. Visiblement, nous avons besoin de convertir les demi-tons en Hertz. Nous pouvons le faire au niveau primaire (avec le module Expon. (F)) ou bien à l’intérieur de notre structure Reaktor Core. Comme nous sommes en train d’apprendre à construire une structure Reaktor Core, choisissons la deuxième option. Effectuez un clic droit sur le fond de la zone normale (au cent…) et sélectionnez Standard Macro > Convert > P2F: REAKTOR CORE – 31 Comme son nom l’indique (et comme le texte d’info le confirme), ce module convertit une échelle “P” en échelle “F” –exactement ce dont nous avons besoin! Créons donc une deuxième entrée nommée “P” et connectons-la via le module P2F: Tout cela devrait être suffisant. Mais, dans notre instrument, il reste le potentiomètre “P Cutoff”, définissant la fréquence de coupure de base du filtre qui est ajoutée au signal de modulation venant de l’enveloppe. Ce signal est converti en signal évènement au niveau primaire pour pouvoir alimenter l’entrée “P” du filtre. Cette conversion n’est évidemment plus nécessaire, nous pouvons retirer le module A/E et brancher directement le signal audio dans l’entrée audio “P” de notre nouveau filtre. Cette méthode est loin de nous déplaire, mais nous vous en suggérons une autre… pour la beauté du geste. Nous allons partir d’une entrée “P” en mode évènement et une entrée de modulation en mode audio. Si vous vous rappelez de notre discussion à propos des “enveloppes lentes”, vous comprendrez pourquoi nous suggérons d’appeler cet autre module d’entrée “PM”, et non “FM”, et d’utiliser une modulation en demi-tons (le “P” vient de “Pitch”, “hauteur tonale” en anglais). C’est exactement ce qui se passe dans l’instrument original: nous additionnions le signal d’enveloppe avec le signal “P Cutoff” et branchions la somme dans l’entrée “P”. Passons donc notre entrée “P” en mode énèvement (nous avons déjà décrit plus haut comment faire) et ajoutons une entrée “PM” en mode audio: Comme un utilisateur du niveau primaire de Reaktor pourrait s’y attendre, nous devrions pouvoir additonner les deux signaux tout de suite. Mais dans 32 – REAKTOR CORE Reaktor Core, le module Add est considéré comme un module de bas niveau et suppose quelque connaissance des principes fondamentaux de fonctionnement du bas niveau de Reaktor Core. Ils ne sont pas si compliqués que cela, et nous les décrirons. Mais à ce stade, ils ne feraient que vous encombrer l‘esprit. Utilisez plutôt un mixeur de signaux de contrôle, par exemple Standard Macro > Control > Ctl Mix: La dernière entrée dont nous avons besoin est la résonance. Sa forme audio ne nous est d‘aucune utilité, utilisons donc un évènement: Il nous reste à donner un nom à notre cellule core. Pour accéder à ses propriétés, cliquez sur le fond si la fenêtre Properties est déjà ouverte, sinon faites un clic droit sur le fond et choisissez la commande Owner Properties: REAKTOR CORE – 33 Vous pouvez alors saisir un texte dans le champ de nom (Label): Double-cliquez sur le fond pour voir le résultat: Le module a fière allure! On pourrait objecter que l’entrée du signal audio est en haut de la cellule core, alors qu’elle était en bas du module filtre du niveau primaire. Honnêtement, ce n’est pas un gros problème; si vous tenez absolument à arranger cela, ce n’est pas très compliqué, vous savez déjà comment faire. Mais faisons-le ensemble, nous en profiterons pour vous montrer en chemin une nouvelle fonction. Retournons donc à l’intérieur de la structure core et commençons par déplacer l’entrée du signal audio tout en bas: Cela suffit, si ce n’est que maintenant un câble diagonal traverse toute la structure, ce qui n’est pas très seyant. Voilà comment nous allons résoudre ce problème. 34 – REAKTOR CORE Effectuez un clic droit sur la sortie du module d’entrée In et sélectionnez la commande Connect to New QuickBus: Vous devriez maintenant voir ceci: La fenêtre Properties devrait également afficher les propriétés du QuickBus que vous venez de créer. La propriété la plus utile du QuickBus est bien sûr de pouvoir le renommer (les autres propriétés sont assez avancées, laissonsles tranquilles pour l’instant). Vous pourrez rouvrir la fenêtre Properties plus tard en double-cliquant sur le QuickBus. Bien que vous puissiez renommer ce QuickBus, nous pensons que son nom actuel est parfaitement approprié, puisqu’il correspond au nom de l’entrée qui lui est connectée. Les QuickBus sont internes à la structure en question, il n’y a donc pas de risque de collisions de noms si des QuickBus des structures voisines ou parentes portent le même nom. Étape suivante: effectuer un clic droit sur l’entrée du haut du module filtre 2 Pole SV C et de sélectionner Connect to QuickBus > In: REAKTOR CORE – 35 Dans le menu ci-dessus, In n’est rien d’autre que le nom du QuickBus auquel vous vous connectez. Ici, vous ne souhaitez pas créer de nouveau QuickBus, mais connecter l’entrée en question au QuickBus déjà existant. Voilà à quoi votre structure doit ressembler: À la place du câble diagonal hideux, nous avons maintenant deux jolies références indiquant qu’elles sont connectées via un QuickBus nommé In. Revenons au niveau primaire et modifions notre structure pour utiliser le filtre que nous venons de construire. Vous pouvez vous débarrasser des modules Add et A/E. Et voilà le résultat: Notre nouvelle structure utilise un peu plus de puissance processeur, n’est-ce pas ? N’oubliez pas que ce filtre est modulé par un signal audio en échelle de demi-tons. S’il ne vous plaît pas, vous pouvez revenir à l’ancienne structure ou utiliser le module filtre Multi 2 pole FM du niveau primaire (les “enveloppes lentes”, vous vous rappelez ?), mais nous espérons qu’il vous plaît. Dans le cas contraire, il y a plein d’autres filtres avec de nouvelles fonctions qui vous plairont peut-être plus. Et si vous n’aimez pas les nouveaux filtres Reaktor Core, il y a une foule d’autres modules Reaktor Core que vous pouvez essayer. 36 – REAKTOR CORE 2.3. Les signaux audio et les signaux de contrôle Avant de poursuivre, nous devons regarder d’un peu plus près une convention particulière utilisée dans les Standard Macros de la librairie Reaktor Core. Les modules qui s’y trouvent peuvent être catégorisés selon le type de signaux qu’ils traitent: audio, de contrôle, évènement et logique. Nous expliquerons les signaux évènements et logiques un peu plus tard, concentrons nous d’abord sur les deux premiers types de signaux. Les signaux audio sont les signaux transportant de l’information audio (sic). Ils comprennent les signaux sortant des oscillateurs, filtres, amplificateurs, delays, etc. Ainsi, les modules comme les filtres, amplificateurs, saturations et autres delays doivent normalement recevoir en entrée un signal audio à traiter. Les signaux de contrôle ne transportent pas d’audio, ils servent juste à contrôler certains modules. Par exemple, les sorties des enveloppes, des LFOs, les signaux de pitch (hauteur tonale) et de vélocité des notes du clavier ne transportent aucun son mais peuvent servir à contrôler la fréquence de coupure ou la résonance d’un filtre, la durée d’un délai ou quoi que ce soit d’autre. Ainsi, les ports d’entrée de fréquence de coupure ou de résonance d’un filtre ou de durée de délai sont supposés recevoir des signaux de contrôle. Voilà un exemple de module filtre Reaktor Core que vous connaissez déjà: L’entrée supérieure du filtre est prévue pour recevoir le signal audio à filtrer et attend donc un signal de type audio. Les entrées F et Res sont visiblement de type contrôle. Les sorties du filtre produisent différentes sortes de signaux audio filtrés, elles sont donc toutes de type audio. Un module oscillateur sinusoïdal, quant à lui, dispose d’une unique entrée de contrôle (pour la fréquence) et d’une unique sortie audio: Si nous observons le module Rect LFO, il dispose de deux entrées de contrôle (pour la fréquence et la largeur de l’impulsion, la troisième entrée étant de type REAKTOR CORE – 37 évènement) ainsi que d’une sortie de contrôle (car le module sert à contrôler d’autres paramètres comme la fréquence de coupure d’un filtre, des niveaux d’amplification, etc.): Certains types de traitements (et mixages) sont utilisés à la fois pour les signaux audio et pour les signaux de contrôle. Dans ce cas, vous trouverez pour ces macros une version dédiée aux signaux audio et une version dédiée aux signaux de contrôle. C’est le cas par exemple des mixeurs audio ou de contrôle, des amplificateurs audio ou de contrôle, etc. Généralement, il est déconseillé d’utiliser un module avec un signal pour lequel il n’est pas prévu, à moins que vous ne sachiez précisément ce que vous faites. Ceci dit, il faut remarquer qu’il est assez souvent possible de réutiliser des signaux audio comme signaux de contrôle. L’exemple le plus typique est la modulation de la fréquence d’un oscillateur ou de la fréquence de coupure d’un filtre par un signal audio. Ceci fonctionne sans problème, à partir du moment où vous utilisez intentionnellement ce signal audio comme un signal de contrôle. Nous osons croire que le cas contraire, ie l’utilisation volontaire d’un signal de contrôle en tant que signal audio, est plutôt rare... Cette séparation entre les signaux audio, de contrôle, évènement et logique ne doit pas être confondue avec la séparation audio/évènement du niveau primaire de Reaktor. La classification audio/évènement du niveau primaire spécifie une sorte de “vitesse de traitement” des signaux: les signaux audio sont traités bien plus “vite” (et nécessitent plus de puissance processeur). De plus, comme vous le savez probablement, les signaux évènements du niveau primaire ont des règles de propagation différentes de celles des signaux audio. Dans la terminologie de Reaktor Core, la différence entre les signaux audio, de contrôle, évènements et logiques est purement sémantique: elle définit l’utilisation du signal et non le type de traitement qu’il subit. La relation entre les catégories évènement/audio du niveau primaire et les catégories audio/contrôle/évènement/logique de Reaktor Core n’est pas biunivoque (“bijective” diraient les 38 – REAKTOR CORE purs et durs), mais nous pouvons quand même tenter de la détailler: - - - - un signal audio du niveau primaire correspond normalement dans Reaktor Core soit à un signal audio (p.ex. la sortie d’un oscillateur ou d’un filtre), soit à un signal de contrôle (p.ex. la sortie d’une enveloppe). un signal évènement du niveau primaire est généralement un signal de contrôle dans Reaktor Core. Comme exemple, on peut citer la sortie d’un LFO, d’un potentiomètre, d’une source MIDI de pitch ou de vélocité. parfois, un signal évènement du niveau primaire correspond à un signal évènement dans Reaktor Core. L’exemple le plus typique est un MIDI Gate (les signaux évènements de Reaktor Core seront décrits plus loin, comme promis). parfois, un signal évènement du niveau primaire ressemble à un signal logique de Reaktor Core, bien qu’ils ne soient pas entièrement compatibles et qu‘une conversion explicite entre les deux soit nécessaire (nous traiterons aussi de ce sujet plus loin). On peut prendre comme exemple les signaux traités par Logic AND ou d’autres modules similaires du niveau primaire. Il est important de comprendre que, lorsque vous sélectionnez un type de signal pour un port d’entrée d’une cellule core, vous choisissez en fait entre un signal évènement et un signal audio du niveau primaire et non du niveau Reaktor Core! Les ports de la cellule core sont à la jonction des deux mondes, c’est la raison pour laquelle ils utilisent dans certains cas la terminologie du niveau primaire. Nous allons en apprendre un peu plus sur ces distinctions en essayant de construire une émulation d’effet d’écho à bande. Nous commencerons par construire un simple écho numérique, puis nous l’améliorerons pour imiter certaines caractéristiques d’un écho à bande. Créons d’abord une cellule core vide. Pénétrez-y et renommez-la “Echo”. Le premier module que nous allons placer dans la structure est un module de délai. Prenons un délai à interpolation 4-points, car il est de meilleure qualité qu’un 2-points, et car un délai sans interpolation ne conviendrait pas à notre émulation de bande. Sélectionnons donc Standard Macro > Delay > Delay 4p: REAKTOR CORE – 39 Nous avons évidemment besoin d’une entrée et d’une sortie audio pour notre cellule core de délai. Nous allons utiliser une connexion QuickBus pour l’entrée et une connexion normale pour la sortie: Il nous faut également une entrée événement pour contrôler la durée du délai. Il faut ici prendre en compte le fait que la durée de délai au niveau primaire est généralement exprimée en millisecondes, alors qu’au niveau Reaktor Core elle est exprimée en secondes. Pas de problème, un petit convertisseur est disponible, Standard Macro > Convert > ms2sec: À ce point, nous n’avons qu’un écho simple, et il serait agréable de pouvoir entendre le signal original et pas uniquement le signal avec écho. Nous devons donc mixer le signal original avec le signal retardé. Comme nous voulons mixer des signaux audio, nous avons besoin d’un mixeur audio (si vous vous en rappelez, nous avons utilisé un mixeur de contrôle pour mixer des signaux de contrôle lorsque nous avons construit la cellule core de filtre). Encore mieux, nous pouvons utiliser un mixeur audio spécialement conçu pour mélanger deux signaux (bref un “crossfader”): Standard Macro > Audio Mix-Amp > XFade (par): 40 – REAKTOR CORE Le qualificatif “(par)” signifie “parabolique” – pour donner une transition plus naturelle que la transition linéaire. Nous allons connecter l’entrée de contrôle (“x”) du crossfader à une nouvelle entrée évènement qui contrôle la balance entre les signaux original et retardé. Lorsque le signal de contrôle est égal à 0, nous n’entendons que le signal original, tandis que s’il est égal à 1 nous n’entendons que le signal retardé: C’est bien mieux maintenant, puisque nous pouvons entendre le signal original et son écho. Mais ce n’est toujours qu’un écho. Pour avoir plusieurs échos, nous devons réinjecter une partie du signal retardé dans l’entrée du délai. Nous devons donc d’abord atténuer le signal retardé. D’après les mêmes considérations – un amplificateur audio pour un signal audio, prenons Standard Macro > Audio Mix Amp > Amount: Nous utilisons l’ampli Amount car nous voulons contrôler la quantité de signal réinjectée. Cet amplificateur nous permet aussi d’inverser le signal en utilisant des réglages négatifs. En revanche, un ampli comme Amp (dB), qui conviendrait mieux pour contrôler un volume sonore, ne serait pas très intéressant dans notre cas, car il ne permet pas d’inverser le signal. Connectons l’entrée de contrôle d’amplitude de l’amplificateur à une entrée évènement que nous créons pour contrôler la quantité de réinjection: REAKTOR CORE – 41 Les quantités raisonnables de réinjection se situent dans l’intervalle [-0.9..0.9]. Si vous souhaitez tester ce délai dès l’étape suivante, faites attention à la quantité de réinjection, car vous pouvez facilement atteindre des niveaux trop élevés (il n’y a pas encore de saturation dans notre circuit). Nous aurions pu équiper notre cellule core d’un limiteur de réinjection de sécurité, mais comme nous voulons ensuite y adjoindre une saturation, nous n’avons pas jugé cela nécessaire. En revanche, vous pourriez faire des essais avec des réinjections hautes et entendre la saturation du délai. Nous devons maintenant mixer le signal de réinjection avec le signal original. Un mixeur audio (Standard Macro > Audio Mix Amp > Audio Mix) semble un choix naturel: : Vous vous demandez peut-être ce qui est arrivé à l’entrée supérieure du module Amount ci-dessus, celle qui affiche maintenant un gros “Z” orange: En fait, selon la version du logiciel et les circonstances, ce “Z” peut apparaître à d’autres entrées de la structure, mais cela ne doit pas vous inquiéter plus que cela. Ce symbole indique qu’un délai numérique est apparu dans la structure à cet endroit. Il est utile à la conception de structures évoluées, pour lesquelles cette information peut être importante pour le concepteur. Pour les structures simples comme celle qui nous occupe, nous pouvons oublier ce symbole. Sa présence montre juste qu’il existe un délai d’1 échantillon (environ 0,02 ms à 44,1 kHz, encore moins aux taux d’échantillonnage plus élevés) en ce point. Nous osons prétendre que vous ne remarquerez rien si le délai est décalé de 0,02 ms par rapport à la valeur que vous avez spécifiée... Revenons à notre structure. Elle peut maintenant produire une série d’échos 42 – REAKTOR CORE décroissants. Elle devrait être suffisante pour un écho numérique, mais nous voulons vous montrer une autre caractéristique de la librairie, une astuce qui vous permettra de réduire la taille de votre structure. Parmi les amplificateurs audio, certains sont appelés “Chain”. Ces amplificateurs sont capables d’amplifier un signal donné et de le mélanger à un autre signal “enchaîné”. L’un de ces amplis, Audio Mix Amp > Chain(amount), fonctionne comme Amount si ce n’est cette caractéristique “d’enchaînement”: Le signal arrivant à la deuxième entrée de ce module est atténué selon le facteur donné par l’entrée “A” puis mélangé au signal arrivant dans l’entrée de chaîne (“>>”). Le signal arrivant dans cette entrée de chaîne n’est pas atténué. Ce type d’amplificateur peut servir à construire des chaînes de mixage, dans lesquelles les connexions des ports “>>” constituent une sorte de bus de mixage: Dans le cas qui nous concerne, nous n’avons pas besoin de bus de mixage, mais nous pouvons utiliser ce module à la place de l’ensemble Audio Mix et Amount. Le signal réinjecté sera atténué de la quantité spécifiée par l’entrée Fbk et mixé avec le signal d’entrée exactement comme auparavant: Félicitations! Vous avez construit un effet d’écho numérique simple. La prochaine étape sera d’y ajouter un effet de simulation de bande. REAKTOR CORE – 43 2.4. Création de vos premières macros Reaktor Core Pour l’effet d’écho que nous venons de construire, nous avons utilisé une macro Delay 4p de la librairie qui nous offre un délai numérique de bonne qualité. Mais bonne qualité ou pas, il sonne toujours trop “numérique”. Nous pourrions lui donner un son plus chaud en lui ajoutant quelques caractéristiques typiques d’un écho à bande, comme la saturation et l’effet de pompage. C’est ce que nous allons réaliser maintenant. Commençons par supprimer la macro de délai de la structure, et créons une macro vide à la place via un clic droit sur le fond de l’écran et en sélectionnant Built In Module > Macro: Double-cliquez sur cette macro pour pénétrer à l’intérieur. Vous voyez apparaître une structure vide similaire à celle de la cellule core précédente: Elle fonctionne aussi de façon semblable, avec toutefois quelques différences importantes. Nous avions alors la structure d’une cellule Reaktor Core alors que nous avons maintenant la structure interne d’une macro Reaktor Core. En réalité, ces différences concernent l’ensemble des modules d’entrée et de sortie disponibles: 44 – REAKTOR CORE Les ports de type Latch et Bool C seront expliqués bien plus loin dans ce manuel; ils servent pour les opérations avancées. Pour l’instant, nous nous intéresserons uniquement à la sortie intitulée “Out” (ou “In” pour les entrées). C’est un type général de port, qui peut accepter des signaux audio, logiques, de contrôle et évènements. En fait, le port n’a cure du type de signal qu’il reçoit: cette différenciation n’est utile que pour vous, en tant qu’utilisateur, parce qu’elle définit ce à quoi doit servir le signal. Pour Reaktor Core, tous les signaux sont identiques. La différence entre entrées/sorties audio et événement de la structure précédente n‘existe plus, car il n’y a plus de niveau primaire à l’extérieur (contrairement à ce qui se passe pour une cellule core): nous sommes maintenant entièrement dans Reaktor Core. La première chose que nous allons faire est de nommer la macro, de la même façon que pour la cellule core, via un clic droit sur le fond et en sélectionnant Owner Properties, où vous pouvez saisir le nom: Les autres propriétés de la macro contrôlent divers aspects de l’apparence et du traitement du signal pour cette macro. Même si vous êtes libre d’expérimenter différents réglages pour ces autres propriétés, nous vous conseillons fermement de laisser le paramètre Solid activé et de modifier le paramètre FP Precision avec modération. La signification de ces paramètres sera expliquée dans les sections avancées de ce manuel. Créons ensuite un ensemble d’entrées/sorties pour notre macro Tape Delay: REAKTOR CORE – 45 L’entrée supérieure recevra le signal audio, l’entrée inférieure le paramètre temporel. Vous avez peut-être remarqué la présence de ports supplémentaires sur la gauche des modules d’entrée, nous les expliquerons plus loin. Au centre de notre macro, nous allons utiliser comme point de départ le même module Delay 4p: Une simulation simple de l’effet de saturation peut être réalisée facilement, il suffit de connecter un module saturateur avant le délai. Le saturateur est une sorte de modeleur de signal et il travaille sur de l’audio, nous allons donc le chercher parmi les modeleurs audio (en anglais “audio shapers”). Sélectionnons Standard Macro > Audio Shaper > Parabol Sat: Le signal d’entrée est maintenant saturé sur un intervalle de –1 à +1. En fait, cet intervalle est contrôlé par l’entrée “L” du module saturateur; si celle-ci est déconnectée, la valeur est égale à 1 par défaut. Ceci peut vous paraître surprenant, puisque d’habitude une entrée déconnectée est considérée comme ne recevant aucun signal, autrement dit un signal nul. Ce n’est pas exactement le cas dans les structures Reaktor Core, les modules ont la possibilité de spécifier un traitement spécial pour leurs entrées déconnectées, comme pour ce saturateur dans lequel l’entrée “L” doit avoir 1 comme valeur par défaut. Nous allons maintenant apprendre comment effectuer ce réglage, pour la valeur par défaut de l’entrée “T”. Mettons que, si notre entrée “T” est déconnectée, nous voulions qu’elle soit traitée comme si la valeur d’entrée était de 0,25 46 – REAKTOR CORE secondes. Rien de plus simple: faites un clic droit sur ce nouveau port sur la gauche du module d’entrée “T”, et sélectionnez Connect to New QuickConst. Voilà ce que vous devriez voir: De plus, la fenêtre de propriétés devrait afficher les propriétés de cette constante (si la fenêtre affiche une page différente, appuyez sur le bouton ): Dans le champ de valeur (“Value”), saisissez la nouvelle valeur “0.25”: Voilà ce que vous devriez voir maintenant: Expliquons ce que nous venons de faire. Le port sur la gauche des modules d’entrée spécifie un signal “par défaut”, c’est-à-dire un signal utilisé si l’entrée n’est pas connectée (à l’extérieur de la macro). Dans notre cas, si l’entrée “T” de la macro Tape Delay n’est pas connectée à l’extérieur, elle se comportera comme si vous lui aviez connecté une constante de valeur 0,25. REAKTOR CORE – 47 Une connexion à une QuickConst n’est évidemment pas la seule possibilité pour un signal par défaut. Vous pouvez lui connecter n’importe quel autre module de la structure, y compris un autre module d’entrée. Maintenant que nous avons une saturation et une valeur par défaut pour l’entrée “T”, simulons l’effet de pompage de la bande. Une façon simple de le faire est de moduler la durée de délai par un LFO (pour “Low Frequency Oscillator”, “Oscillateur Basse Fréquence” en anglais). Nous pourrions essayer différentes formes de LFOs pour obtenir un meilleur effet de pompage. Nous proposons pour l’instant d’en prendre un seul dans la librairie: Standard Macro > LFO > Par LFO: C’est un LFO parabolique produisant un signal qui ressemble par sa forme à une sinusoïde, mais qui nécessite moins de puissance processeur. Son entrée “F” doit recevoir le signal spécifiant sa vitesse d’oscillation (sa fréquence). Nous pouvons à nouveau utiliser une constante QuickConst. Une fréquence de 4 Hz semble raisonnable: L’entrée “Rst” sert à redémarrer le LFO (“Rst” pour “Reset”, “Redémarrer” en anglais), nous ne nous en servirons pas pour l’instant. Nous devons maintenant spécifier une quantité de modulation en redimensionnant la sortie du LFO, car il génère pour l’instant un signal compris entre –1 et 1, ce qui est beaucoup trop. Ne perdant pas de vue que nous avons ici affaire à des signaux de contrôle, nous allons utiliser un module d’amplification de contrôle, similaire à l’amplificateur Amount que nous avons utilisé pour l’audio, Standard Macro > Control > Ctl Amount: Une amplitude de modulation de 0,0002 devrait faire l’affaire, réduisons donc le signal de ce facteur: 48 – REAKTOR CORE Enfin, nous pouvons mixer les deux signaux de contrôles (celui de l’entrée “T” et celui du module Ctl Amount) et les envoyer dans l’entrée “T”du module de délai. Le module Ctl Mix déjà familier peut être à nouveau utilisé: En fait, nous retrouvons la structure de mixeur “en chaîne” que nous avions pour les signaux audio. Nous pouvons donc remplacer les modules Ctl Amount et Ctl Mix comme nous l’avons fait pour le chemin du signal audio, avec cette fois-ci le module Standard Macro > Control > Ctl Chain: Nous pouvons apporter la touche finale à notre macro: changer la taille du tampon pour notre délai, qui définit la durée de délai maximale. Si vous maintenez le curseur sur la macro Delay 4p (et pour peu que le bouton soit activé), vous pouvez lire dans le texte d’info que la taille de tampon (en anglais “buffer”) par défaut correspond à 1 seconde à 44,1 kHz: REAKTOR CORE – 49 Passons-le à 5 secondes, soit 44100*5 = 220500 (au fait, puisque chaque échantillon occupe 4 octets, ceci fait en tout 220500*4 = 882000 octets, soit presque 1 Mo). Double-cliquez sur la macro Delay 4p: Le module sur la gauche est le module du tampon du délai. Double-cliquez dessus (ou faites un clic droit et sélectionnez Show Properties) pour modifier ses propriétés. Sélectionnez la page , dans laquelle vous devriez voir s‘afficher la propriété Size (Taille en anglais...). Réglez-la sur 220500 échantillons: Comme nous l’avons vu, un tampon de 5 secondes d’audio prend environ 1 Mo de mémoire, donc soyez prudent lorsque vous modifiez les tampons de délai, tout particulièrement si les délais sont utilisés dans 50 – REAKTOR CORE des parties polyphoniques de la structure, dans lesquelles la taille du tampon sera multipliée par le nombre de voix ! Nous pouvons resortir de la macro Delay 4p puis de la macro Tape Delay que nous venons de créer (double-cliquez sur le fond), pour nous occuper des connexions externes: Si vous ne l’avez pas encore fait, nous vous suggérons d’essayer le module d’écho que nous avons construit. Voici une structure de test du niveau primaire de Reaktor, aussi simple que possible (veuillez noter que le module d’écho est réglé sur mono): Vous pouvez l’améliorez de multiples façons, par exemple en insérant des potentiomètres contrôlant les différents paramètres de l’écho, en utilisant un véritable synthétiseur comme signal source, etc. 2.5. Utiliser l’audio comme signal de contrôle Nous avons mentionné plus haut qu’il était possible d’utiliser un signal audio en tant que signal de contrôle. Nous avons pensé qu’il serait utile d’en donner un exemple. Nous allons créer une cellule core implémentant une paire d’oscillateurs, l’un des deux étant modulé par l’autre. Prenons deux oscillateurs multi-ondes (en anglais “multiwave”): REAKTOR CORE – 51 Nous aurons besoin d’un contrôle de pitch (hauteur tonale) pour chacun des deux oscillateurs, et nous écouterons la sortie du deuxième oscillateur. Créons les entrées et sorties correspondantes: Nous voulons maintenant prendre la sortie de l’oscillateur de gauche et l’utiliser pour moduler la fréquence du second oscillateur (celui de droite, donc): L’entrée Mod contrôle la quantité de modulation. Veuillez noter que nous mixons le signal de modulation après le convertisseur P2F, afin que la modulation ait lieu sur l’échelle de fréquences (il serait aussi possible d’effectuer la modulation sur l’échelle de pitch). En fait, il vaut mieux adapter la quantité de modulation en fonction de la fréquence de l’oscillation de base: Maintenant, si vous analysez la structure ci-dessus du point de vue des signaux audio et de contrôle, vous remarquerez que tous les signaux de la structure, excepté les sorties des oscillateurs, sont des signaux de contrôle. Les sorties des deux oscillateurs sont évidemment des signaux audio. Cependant, nous utilisons de façon “détournée” la sortie de l’oscillateur de gauche, la considérant comme un signal de contrôle que nous envoyons dans le mixer Ctl Chain. 52 – REAKTOR CORE 2.6. Les signaux évènements Comme nous l’avons dit précédemment, il y a plusieurs significations à l’expression “signal évènement”. Le concept des signaux évènements du niveau primaire de Reaktor devrait déjà vous être familier. Un signal évènement du niveau primaire peut avoir plusieurs utilisations. Une première consiste à l’utiliser comme signal de contrôle (p.ex. la sortie d’un LFO, d’un potentiomètre, etc.), simplement parce qu’il consomme moins de puissance processeur qu’un signal audio du niveau primaire. Dans ce cas, vous auriez pu utiliser un signal audio à la place et obtenir sensiblement le même effet. Une deuxième utilisation, dans laquelle le signal évènement ne peut être remplacé par de l’audio, se présente lorsque vous êtes intéressé(e) non seulement par les valeurs transportées par le signal, mais aussi par les instants auxquels chaque nouvelle valeur est délivrée par le câble, autrement dit quand l’évènement est envoyé. Comme exemple, citons un signal “gate” d’enveloppe du niveau primaire: l’enveloppe est lancée à l’instant où un évènement arrive à l’entrée de la porte (en anglais “gate”). Lorsque nous parlions de signaux audio, de contrôle, évènements et logiques dans Reaktor Core, nous ne parlions pas vraiment de différences techniques entre ces signaux (techniquement, ils sont tous équivalents dans Reaktor Core), mais plutôt des différentes façons d’utiliser un signal. Comme nous le voyons maintenant, un signal évènement du niveau primaire de Reaktor peut être utilisé comme signal de contrôle, événement, voire logique (alors qu’un signal audio du niveau primaire de Reaktor peut être utilisé comme audio ou comme contrôle, comme vous devriez vous en rappeler...). Nous avons déjà appris à envoyer des signaux évènements du niveau primaire dans Reaktor Core et à les utiliser comme signaux de contrôle. Les entrées en mode évènement de la cellule core audio réalisant un filtre - que nous avons construite auparavant - en est un bon exemple. Il y a également des cas dans lesquels vous utiliseriez plutôt une cellule core évènement pour traiter certains signaux évènements du niveau primaire, qui sont en fait des signaux de contrôle. Voici un exemple de cellule core évènement englobant une macro core de modeleur de type contrôle (Ctl Shaper): REAKTOR CORE – 53 Ce modeleur de contrôle reçoit un signal de contrôle issu d’un signal évènement du niveau primaire (p.ex. un signal de vélocité MIDI, ou un signal de LFO du niveau primaire), il le tord en fonction du paramètre “Shp” et envoie le résultat à la sortie. Une restriction importante des cellules core évènements (mentionnée plus haut) est que toutes leurs sources d’horloge sont désactivées. Ceci signifie que non seulement les oscillateurs et les filtres, mais aussi les enveloppes et les LFOs ne peuvent pas fonctionner dans les cellules core évènements. Ces cellules sont vraiment conçues pour recevoir des évènements du niveau primaire de Reaktor, les traiter et les renvoyer à l’extérieur, comme dans l’exemple ci-dessus. Les signaux dérivés de signaux évènements du niveau primaire peuvent aussi être utilisés comme véritables signaux évènements dans les structures Reaktor Core. Nous allons maintenant regarder d’un peu plus près quelques cas simples d’utilisation d’évènements dans Reaktor Core. Le premier cas est l’utilisation d’une enveloppe dans une structure core. Comme nous venons de le voir, à cause de la restriction concernant les cellules core évènements, nous pouvons uniquement utiliser une cellule core audio. Créons donc une nouvelle cellule core audio et utilisons Standard Macro > Envelope > ADSR: L’entrée supérieure de l’enveloppe est une entrée “gate” qui fonctionne sensiblement comme les entrées “gate” des enveloppes du niveau primaire: cette entrée allume ou éteint l’enveloppe en réponse à des évènements. Pas de problème, créons une entrée évènement dans notre cellule core: 54 – REAKTOR CORE Cette entrée convertira les évènements “gate” du niveau primaire en évènements core. Intéressons-nous maintenant aux entrées A, D, S et R. L’entrée “S” (niveau de maintien, en anglais “sustain”) fonctionne comme au niveau primaire, ie elle attend un signal dans l’intervalle [0...1]: Les entrées A, D et R sont quant à elles légèrement différentes en ce sens que, contrairement aux enveloppes du niveau primaire, elles attendent ici des temps spécifiés en secondes: Ceci peut être géré par Standard Macro > Convert > logT2sec, qui convertit les temps des enveloppes du niveau primaire en secondes: Bien que toutes les entrées de la structure ci-dessus soient en mode évènement, du point de vue sémantique, la première entrée produit un signal évènement alors que les autres produisent des signaux de contrôle. Notre enveloppe dispose de deux ports non encore connectés. Le port GS règle la sensibilité du seuil d’activation (“gate”). Réglé sur 0, l’enveloppe ignore complètement le niveau de l’entrée “gate” et elle est toujours à son amplitude maximale. Réglé sur 1, le niveau de seuil a son effet maximal, comme au niveau primaire de Reaktor. Nous pouvons contrôler cette sensibilité depuis l’extérieur via une nouvelle entrée: REAKTOR CORE – 55 Le port RM spécifie le mode de redémarrage de l’enveloppe: Ce port a un aspect différent car il attend des valeurs entières en entrée. Si nous considérons par exemple l’entrée pour le temps d’attaque, elle peut accepter un temps d’attaque d’1 s, 1,5 s ou 0,2 s. Au contraire, le port pour le mode de redémarrage ne s’attend pas à une valeur de 1,2 ou de 3,1. Ceci est indiqué par l’aspect différent du port, mais cela n’empêche pas de connecter à ce port un signal normal; utilisons donc une autre entrée évènement: 56 – REAKTOR CORE Si les valeurs venant de l’extérieur ne sont pas entières, elles sont arrondies à la valeur entière la plus proche. Par exemple, 1,2 sera arrondi à 1. Observons maintenant un autre exemple d’utilisation d’un signal évènement véritable: La structure ci-dessus réalise une sorte de modulation de pitch (hauteur tonale). L’effet est produit par un délai dont la durée varie dans l’intervalle 250±100 ms. La vitesse de cette variation est contrôlée par l’entrée Rate, qui contrôle en fait la vitesse du LFO (la valeur est en Hertz). Il s’agit donc d’un pur signal de contrôle. L’entrée Rst est un signal évènement, il peut être utilisé pour redémarrer le LFO. La valeur en entrée spécifie la phase de redémarrage, pour laquelle 0 signifie que le LFO redémarre au début du cycle, 0,5 au milieu du cycle et 1 à la fin. Vous pouvez faire des tests en connectant un bouton envoyant des valeurs spécifiques à cette entrée. 2.7. Les signaux logiques Maintenant que nous en savons plus sur les signaux évènements et les signaux de contrôle, il est temps d’en apprendre un peu plus sur une autre manière d’utiliser les signaux dans Reaktor Core, via les signaux logiques. Voici un exemple d’un module qui traite les signaux logiques: Comme vous pouvez le remarquer, les ports de ce module ont un type entier, comme l’entrée RM de l’enveloppe vue plus haut. Ceci est dû au fait que les signaux arrivant ne transportent généralement que des valeurs entières, et même “pire”, ils ne transportent que des 0 et des 1. Pour le signal logique, la valeur 1 correspond à l’état true (vrai en anglais), et la valeur 0 à l’état false (faux en anglais). La signification des expressions true et false doit être assignée par l’utilisateur. Vous pouvez décider qu’un signal logique détermine si une porte (“gate”) particulière est ouverte ou non: REAKTOR CORE – 57 Ici, une macro Gate2L vérifie le signal d’entrée et produit une sortie true (ou 1) si la porte est ouverte et false (ou 0) si elle est fermée. Vous pouvez utiliser les signaux logiques pour effectuer des “traitements logiques”. Par exemple, nous pourrions construire un processeur de porte logique qui appliquerait à une porte logique MIDI une autre porte, régulièrement cadencée, basée sur une horloge Les modules Gate2L, AND et L2Gate sont des modules logiques et se trouvent dans le menu Standard Macro > Logic. Le Gate LFO est une macro que nous avons construite pour ce processeur. Elle génère un signal de porte, s’ouvrant et se fermant à intervalles réguliers. La porte en entrée et la sortie du LFO sont connectées à des convertisseurs Gate2L qui convertissent les signaux de portes en signaux logiques, transformant les portes ouvertes en true et les portes fermées en false. Le module AND sort la valeur true si et seulement si les deux portes sont à l’état ouvert en même temps. En d’autres termes, la sortie du module AND est égale à true si et seulement si l’utilisateur maintient une touche enfoncée et si en même temps le LFO produit une porte ouverte. Ceci signifie que, tant que l’utilisateur maintient une touche enfoncée, il y aura alternativement des valeurs true et false en sortie du module AND, la vitesse d’alternance étant réglée par la fréquence du LFO. La sortie du module AND est reconvertie en signal de porte, l’amplitude du signal est prise du signal de porte en entrée, pour que le niveau du signal de porte reste inchangé. Voici la structure de notre macro Gate LFO: 58 – REAKTOR CORE L’entrée F définit la vitesse des répétitions d’ouverture de la porte, et l’entrée W définit la durée d’ouverture des portes (à 0, elles restent ouvertes la moitié du cycle, à –1 elles restent ouvertes 0 % du temps et à 1, 100 % du temps). L’entrée Rst redémarre le LFO en réponse aux évènements entrants (le LFO est donc redémarré à chaque fois qu’un évènement arrive à l’entrée G principale). Le module connecté à l’entrée Rst du Rect LFO est appelé Value et se trouve dans Standard Macro > Event Processing. Il assure que le LFO est redémarré avec une phase nulle en remplaçant toutes les valeurs des évènements entrants par la valeur de l’entrée inférieure, qui est en l’occurrence 0. La sortie du LFO est convertie en signal de porte via un convertisseur Ctl2Gate, que l’on trouve aussi dans Standard Macro > Event Processing. Comme nous l’avons vu, les LFOs ne fonctionnent pas dans les cellules core évènements, donc si vous voulez essayer cette structure, vous devez utiliser une cellule core audio. REAKTOR CORE – 59 3. Fondements de Reaktor Core: le modèle du signal core 3.1. Les valeurs La plupart des sorties des modules de Reaktor Core produisent des valeurs. “Produire” une valeur signifie qu’à tout moment une valeur est associée à la sortie en question. Cette valeur est disponible pour les modules dont les entrées sont connectées à cette sortie. Dans l’exemple suivant, un module additionneur obtient les valeurs 2 et 3 de deux autres modules, dont les sorties sont connectées à ses entrées; l’additionneur produit la valeur 5 à sa sortie � �� �� �� �� Si vous voulez faire une analogie avec le monde matériel, pensez les valeurs comme des niveaux de signaux (des tensions électriques), en particulier si vous avez affaire à des modules de grande échelle tels que les oscillateurs, les filtres, les enveloppes, etc. Cependant, les valeurs ne se limitent pas à cela. Après tout, ce ne sont que des valeurs, et elles peuvent être utilisées pour réaliser n’importe quel algorithme de traitement, pas seulement pour modeler un voltage. 3.2. Les évènements Dans le monde numérique, le temps n’est pas continu, il est discret, c’est-à-dire quantifié. L’un des exemples les plus connus est l’enregistrement numérique, qui n’enregistre pas l’information totale d’un signal audio évoluant continûment dans le temps, mais seulement son niveau à des instants précis régulièrement espacés. Le nombre de ces instants dans chaque seconde définit le fameux taux d’échantillonnage. 60 – REAKTOR CORE Voici la représentation d’un signal continu: � et sa représentation numérique (ou digitale): � Ceci implique que, puisque nous sommes dans le monde numérique, les sorties de nos modules ne peuvent faire évoluer leurs valeurs de façon continue. D’un autre côté, nous n’avons pas besoin de forcer nos sorties à changer leur valeur “à des instants précis régulièrement espacés”, autrement dit nous n’avons pas besoin de maintenir un taux d’échantillonnage particulier tout au long de nos structures. En outre, dans certaines parties de nos structures, nous n’avons pas même besoin de maintenir un quelconque taux d’échantillonnage, autrement dit nos changements n’ont pas besoin de survenir “à des instants précis régulièrement espacés”. Par exemple, au temps zéro, la sortie de notre additionneur a la valeur 5. Le premier changement pourrait survenir au temps 1 ms (une milliseconde). Le deuxième pourrait survenir à 4 ms. Le troisième à 6 ms: � ��� �� �� �� �� �� �� �� �� �� ���������� REAKTOR CORE – 61 Sur la figure ci-dessus, nous voyons les changements de la sortie de notre additionneur survenant entre 0 et 7 ms. À l’instant où la sortie change de valeur, elle génère un évènement. Un évènement signifie que la sortie “rend compte” d’un changement de son état, en l’occurrence qu’elle change de valeur. Dans l’exemple suivant, le module en haut à gauche a modifié sa valeur de 2 à 4, générant un évènement. En réponse, l’additionneur change aussi sa valeur de sortie et génère également un évènement à sa sortie. � ��� �� �� ��� Le module supérieur gauche aurait aussi pu générer un nouvel évènement avec la même valeur que l’ancienne. L’additionneur aurait quand même répondu en générant aussi un nouvel évènement, bien sûr sans changer non plus sa valeur de sortie. � ��� �� �� ��� La nouvelle valeur apparaissant à la sortie ne doit pas forcément être différente de l’ancienne. Cependant, la seule manière pour une sortie de changer sa valeur est de générer un évènement. Comme vous l’avez vu dans les exemples précédents, un évènement survenant à la sortie d’un module va être perçu par les modules connectés “en aval”, qui produiront en réponse d’autres évènements (comme l’additionneur qui produisait un évènement en réponse à l’évènement provenant du module en haut à gauche). Ces nouveaux évènements vont à leur tour être perçus par les modules connectés aux sorties correspondantes et propagés de proche en proche, jusqu’à ce que la propagation s’arrête, pour une des raisons dont nous discuterons plus loin dans ce texte. 62 – REAKTOR CORE Dans Reaktor Core, les évènements sont différents des évènements du niveau primaire de Reaktor. Ils suivent des règles différentes que nous détaillerons plus loin. 3.3. Évènements simultanés Considérons la situation suivante: les deux modules de gauche des exemples précédents produisent simultanément un évènement. � ��� �� ��� ��� Ceci est l’une des caractéristiques essentielles de Reaktor Core: les évènements peuvent survenir simultanément en plusieurs endroits. Dans cette situation, les évènements produits simultanément par les deux modules de gauche arrivent aussi simultanément aux entrées de l’additionneur. En réponse, l’additionneur va produire exactement un évènement à sa sortie. Ce comportement est différent de celui observé au niveau primaire de Reaktor, dans lequel les évènements ne peuvent pas survenir simultanément: dans une telle situation, l’additionneur (en mode évènement) produirait deux évènements en sortie. Bien sûr, en réalité les évènements ne sont pas produits simultanément par les modules supérieur gauche et inférieur gauche, car les deux modules sont traités par le même processeur, et un processeur ne peut jamais traiter qu’un seul module à la fois. Mais l’important pour nous est que ces évènements sont logiquement simultanés, c’est-à-dire qu’ils sont traités comme simultanés par les modules qui les reçoivent. Nous allons maintenant prendre un autre exemple d’une propagation simul� tanée d’évènements. ��� ��� ����� �� ����� REAKTOR CORE – 63 Dans la figure ci-dessus, le module à l’extrême gauche envoie un évènement, modifiant sa valeur de 2 à 3. L’évènement est envoyé simultanément à la fois aux modules inverseur (-x) et multiplicateur (*). En réponse à l’évènement entrant, l’inverseur produit une nouvelle valeur de sortie, -3. Il est important de remarquer que, bien que l’évènement en sortie de l’inverseur soit produit en réponse à l’arrivée de l’évènement venant du module tout à gauche, et donc qu’il doive survenir après ce dernier, les deux évènements restent logiquement simultanés. Ceci signifie qu’ils arrivent simultanément aux entrées du multiplicateur et que le multiplicateur, en réponse, ne produit qu’un seul évènement en sortie, avec une valeur de -9. Dans le niveau primaire, vous auriez eu ici deux évènements à la sortie du module multiplicateur. Vous n’auriez pu déterminer si l’évènement produit à la sortie du module de gauche avait d’abord été envoyé à l’inverseur ou au multiplicateur (bien que cela soit sans importance pour cette structure particulière). En général, vous pouvez utiliser la règle suivante pour déterminer si deux évènements particuliers sont simultanés ou non: Tous les évènements issus d’un (envoyés en réponse à un) même évènement sont simultanés. Tous les évènements issus d’un nombre arbitraire d’évènements simultanés (survenant à différentes sorties mais que l’on sait simultanés) sont aussi simultanés. Le dernier exemple montre l’utilisation de la simultanéité d’évènements. Dans ce cas, nous éliminons le traitement redondant du second évènement par le multiplicateur, qui aurait nécessité plus de temps processeur. Dans des structures plus grandes, en l’absence d’un tel concept de simultanéité, le nombre d’évènements peut croître de façon incontrôlée, à moins que le concepteur de la structure n’ait apporté un soin particulier à maintenir le nombre d’évènements doublons au plus bas. Au-delà de l’économie en temps de processeur, ce concept mène à des différences importantes dans l’approche de la construction des structures, en particulier pour les structures réalisant des algorithmes de traitement du signal (DSP) de bas niveau. Vous comprendrez et percevrez mieux ces différences lorsque vous commencerez à construire vos propres structures. 64 – REAKTOR CORE 3.4. L’ordre de traitement Comme nous l’avons vu dans les exemples précédents, lorsqu’un module envoie un évènement, les modules “en aval” y répondent. On pourrait en conclure que, bien qu’ils produisent des évènements “logiquement simultanés”, les modules sont en fait traités de façon non simultanée. On pourrait alors supposer que, pour une connexion, il soit raisonnable de traiter le module “en amont” avant le module “en aval”. Si quelqu’un arrive à ces conclusions... il (ou elle) a absolument raison. La règle générale de l’ordre de traitement des modules est la suivante: Si deux modules connectés traitent des évènements simultanés, alors le module “en amont” est traité en premier. Si les évènements ne sont pas simultanés, l’ordre de traitement des modules correspond bien entendu à l’ordre des évènements traités. Nous déduisons de la règle ci-dessus qu‘un chemin de connexion unidirectionnel (toujours vers l’amont ou toujours vers l’aval) d‘un module au suivant induit un ordre de traitement déterminé de ces deux modules: le module en amont est traité en premier. S’il n’y a pas de chemin unidirectionnel entre les deux modules, leur ordre de traitement est indéfini (pour des évènements simultanés). Ceci signifie que cet ordre est arbitraire et peut changer à tout moment. Le concepteur de la structure doit donc veiller à ce qu’une telle situation n’arrive que pour des modules dont l’ordre de traitement relatif est sans importance, ce qui est généralement le cas tant qu’aucune connexion OBC (cf. plus bas) n’entre en jeu.Here is an example, the digits showing the order of module processing: Voici un exemple, les nombres indiquant l’ordre de traitement: � �� �� �� �� �� Pour la structure ci-dessus, il existe un autre ordre de traitement possible: REAKTOR CORE – 65 � �� �� � �� �� Il n’y a aucun moyen de dire lequel des deux sera choisi par l’application. Heureusement, tant que vous n’utilisez pas de connexions OBC (détaillées plus bas), l’ordre relatif de traitement des modules dans des cas comme celui-ci est tout-à-fait indifférent. Ces règles permettant de déterminer l’ordre de traitement ne peuvent être appliquées s’il y a une réinjection dans les structures, car dans ce cas, pour n’importe quelle paire de modules dans la boucle de réinjection, nous ne pouvons plus dire lequel est “en amont” et lequel est “en aval”. Le problème de la manipulation des réinjections, y compris pour l’ordre de traitement, sera abordé plus tard. � �� �� �� �� �� Pour la structure ci-dessus, il n’est pas possible de définir si le module B est en amont ou en aval du module D, et vice versa (!). Visiblement, il y a une connexion allant vers l’amont de D vers B, mais il y en a également une de B vers D (via E). 3.5. Retour aux cellules core évènements Observons les cellules core évènements du point de vue du concept d’évènement de Reaktor Core que nous venons de décrire. Comme vous vous en rappelez certainement, les cellules core évènements ont des entrées et des sorties évènements. Ces entrées et sorties sont des points 66 – REAKTOR CORE d’interface entre les niveaux primaire et core de Reaktor. Ils font fonction de convertisseurs entre les évènements du niveau primaire et les évènements core, et vice versa. Les règles de conversion sont les suivantes: Les entrées évènements envoient des évènements core à l’intérieur de la structure en réponse aux évènements du niveau primaire venant de l’extérieur. Comme les évènements du niveau primaire extérieur ne peuvent arriver simultanément aux différentes entrées, les évènements produits à l’intérieur ne sont pas non plus simultanés. Les sorties évènements envoient des évènements de niveau primaire à l’extérieur de la structure en réponse aux évènements core venant de l’intérieur. Bien que des évènements core puissent être simultanés en différentes sorties, les évènements du niveau primaire ne peuvent être envoyés simultanément. Ainsi, pour des évènements core simultanés, les évènements correspondants du niveau primaire sont envoyés les uns à la suite des autres, les sorties supérieures envoyant toujours leurs évènements avant les sorties inférieures. Nous allons maintenant tester ces règles en pratique. Essayons de construire un module de traitement d’évènements qui applique un modelage du signal selon la formule: y = 0.25*x*(4-|x|) La représentation graphique de cette fonction ressemble à ceci: � �� �� �� ��� ��� ��� ��� �� �� �� �� �� �� ��� ��� Commençons par créer une nouvelle cellule core évènement avec une entrée et une sortie, appelées respectivement “x” et “y”. REAKTOR CORE – 67 Créons ensuite la structure qui effectue la fonction. Nous devons créer les modules “|x|” (valeur absolue), “-” (soustraction) et deux “*” (multiplication) dans la zone des modules normaux (au centre). Ce ne sont pas des macros core mais bien des modules Reaktor Core préfabriqués. Pour les insérer dans les structures core, effectuez un clic droit sur le fond de la zone normale et sélectionnez le sous-menu Built-In Module: Vous trouverez tous les modules dont nous avons besoin dans le sous-menu Built In Module > Math: 68 – REAKTOR CORE Nous avons besoin de deux valeurs constantes, 0,25 et 4. Nous pourrions utiliser des QuickConsts, tout comme nous l’avons fait dans les premiers chapitres, mais nous pouvons aussi insérer un module de constante réelle via Built In Module > Const (comme avec QuickConst, la valeur peut être précisée dans la fenêtre Properties): Bien sûr, dans notre cas, il n’y a pas d’intérêt particulier à utiliser des modules Const en lieu et place des QuickConsts, mais cela peut parfois se révéler utile (p.ex. si la même constante doit être connectée à plusieurs entrées, il peut être judicieux d’utiliser un module Const, parce qu’alors vous n’avez besoin que d’un seul module, et vous avez en outre un point unique pour contrôler la valeur de toutes les entrées). Bref, la structure maintenant créée modèle bien le signal de la manière voulue. Nous pouvons nommer notre module et revenir au niveau primaire: Maintenant, testons-le. Fixez le nombre de voix de l’instrument Reaktor à 1, pour qu’il soit plus facile d’utiliser un module Meter (Indicateur en anglais): REAKTOR CORE – 69 Créez un module Knob (Potentiomètre en anglais) et un module Meter, et connectez-les à l’entrée et à la sortie de votre module: Réglez les propriétés du potentiomètre et de l’indicateur de niveau. N’oubliez pas de régler l’indicateur pour qu’il affiche sa valeur: 70 – REAKTOR CORE ni de cocher la case “Always Active” (“Toujours actif” en anglais): Maintenant, tournez le potentiomètre et observez l’évolution de la valeur. REAKTOR CORE – 71 La structure de modelage d’évènements que nous venons de construire devrait fonctionner parfaitement pour le modelage de signaux de contrôle, mais elle comporte encore un défaut mineur dans sa façon de traiter les évènements. Nous reviendrons sur ce problème (et nous le résoudrons !) un peu plus tard. 4. Les structures avec état interne 4.1. Les signaux d’horloge La manière dont une cellule Reaktor Core traite les évènements entrants est entièrement fonction du module en question. Normalement, un module traite la valeur entrante d’une certaine manière, mais il peut aussi tout-à-fait l’ignorer. Le cas le plus typique d’un tel traitement est celui des entrées d’horloge. Un exemple de module avec une entrée d’horloge est le Latch (Loquet en anglais). Le Latch n’est pas un module d’usine, c’est une macro, mais c’est néanmoins un exemple parfait pour illustrer le principe d’horloge. Le Latch a deux entrées: une pour la valeur et une pour l’horloge. � �� ����� � En réponse à un évènement entrant, l’entrée de valeur (l’entrée supérieure) enregistre la valeur entrante dans la mémoire interne du loquet, rien n’est envoyé en sortie. L’entrée d’horloge, en réponse à un évènement entrant, envoie vers la sortie la dernière valeur enregistrée (elle ouvre le loquet). À moins que cela ne soit spécifié autrement, l’entrée d’horloge ignore complètement la valeur de l’évènement arrivant, elle répond uniquement à l‘arrivée de l’évènement. Comme nous discutons pour l’instant des signaux d’horloge et non des loquets, les exemples d’utilisation du module Latch seront détaillés plus loin. 72 – REAKTOR CORE De même qu’il existe des modules avec des entrées d’horloge, il paraît clair que certains signaux de la structure ne transportent aucune valeur utilisée par (ou utile pour) le module. Certains signaux peuvent même être produits dans le seul but d’être utilisés comme des sources d’horloge. Appelons-les signaux d’horloge. Un exemple de signal d’horloge est l’horloge du taux d’échantillonnage. Elle produit un évènement pour chaque nouvel échantillon à générer, donc à 44,1 kHz elle “bat” 44100 fois par seconde. La valeur de ce signal n’a pas de sens, elle n’est pas prévue pour servir en quoi que ce soit, et d’ailleurs (dans l’implémentation actuelle) elle est égale à zéro. 4.2. Les Object Bus Connections (OBC) Les Object Bus Connections (OBC, Connexions sur Bus Objet) sont un type spécial de connexion entre les modules. Une connexion OBC entre deux modules “déclare” qu’ils partagent un même objet (ou état) interne. Le cas le plus typique est la paire de modules Read et Write, qui partagent une mémoire commune s’ils sont connectés via OBC. La fonction du module Write est d’écrire une valeur entrante dans la mémoire partagée via OBC. La fonction du module Read est de lire la valeur dans la mémoire partagée via OBC en réponse au signal d’horloge entrant (entrée C). La valeur lue est envoyée à la sortie du module Read. � �� �� �� ����� � ����� �� �� La structure ci-dessus effectue le traitement de la macro Latch (en fait c’est la structure interne de la macro Latch). Les broches M et S des modules Read et Write sont des broches de type Latch OBC. La broche M est l’entrée maîtresse de la connexion et S la sortie esclave de la connexion. L’entrée maîtresse du module Read est connectée à la sortie esclave du module Write (les deux autres broches maîtresse et esclave ne sont pas utilisées). Ainsi, dans cette structure, les modules Write et Read partagent la même mémoire. REAKTOR CORE – 73 Dans la structure suivante, on trouve deux paires de modules Write et Read. Chaque paire dispose de sa propre mémoire. Notez que la connexion du milieu (de la sortie du Read à l’entrée du Write) n’est pas une connexion OBC. � �� �� ���� � �� �� �� ����� � �� ���� � �� ����� � �� �� �� On pourrait se demander quelle différence il peut bien y avoir entre être maître(sse) et esclave. Du point de vue de la possession de l’objet partagé (dans notre cas une mémoire), il n’y a aucune différence. Cependant, comme nous l’avons déjà vu dans les sections précédentes, une règle énonce que les modules “en amont” sont traités avant les modules “en aval” en ce qui concerne le traitement des “évènements simultanés”. De ce fait, dans les deux derniers exemples, les modules Write sont traités avant leurs Read esclaves. L’ordre relatif de traitement des modules connectés par OBC est défini par les mêmes règles que pour les autres modules: les modules “en amont” sont traités en premier. En effet, considérons les deux cas sur l’exemple suivant. Dans les deux cas, l’état original de la mémoire est à 2 et le même évènement de valeur 5 est envoyé aux modules Read et Write. Dans un cas, le module Write est le maître, dans l‘autre c‘est le module Read. � �� �� �� ����� ���� �� �� ����� � � � �� ��� �� On a représenté ci-dessus la structure du premier cas. Le module de gauche envoie un évènement de valeur 5 qui arrive d’abord au module Write, ce qui entraîne l’écriture de la nouvelle valeur 5 dans la mémoire partagée par la paire Write et Read. Maintenant, l’évènement arrive au module Read, fonctionne comme un signal d’horloge et commande l’opération de lecture, qui à son tour lit la valeur de 5 récemment enregistrée et l’envoie à sa sortie. C’est la fonction de la macro Latch de la librairie de macros de Reaktor Core. 74 – REAKTOR CORE Considérons maintenant la structure du second cas: � �� �� �� ����� ���� �� �� ����� � � � ���� � �� Nous avons ici la situation opposée. D’abord, l’évènement d’horloge arrive au module Read, envoyant la valeur de 2 à sa sortie. C’est seulement après cette lecture que l’évènement arrive à l’entrée du module Write, ce qui passe la valeur enregistrée à 5. Cette structure réalise en fait la fonction d’un bloc Z-1 (retard d’un échantillon), très souvent utilisé en théorie du traitement du signal numérique. En effet, la valeur de sortie est toujours en retard d’un échantillon par rapport à l’entrée. Comme nous l’avons mentionné, la structure ci-dessus réalise la fonction Z-1. Mais avant de pouvoir réellement construire ou utiliser vous-même de telles structures, vous devez prendre connaissance de certains points importants. Nous vous conseillons donc de poursuivre votre lecture. Si vous avez plus de deux modules connectés par des câbles OBC, tous ces modules partagent le même état interne. Il devient alors très important de savoir si un ordre particulier d’opérations de lecture et d’écriture doit être appliqué, et si oui, lequel. Par exemple, dans la structure suivante, l’ordre relatif de traitement des deux opérations de lecture est indéfini, mais elles arrivent toutes deux après l’opération d’écriture, il faut donc que cela vous convienne: � �� ����� � �� �� �� �� �� ����� ����� �� �� Dans la structure suivante, l’ordre relatif des opérations de première écriture et de seconde lecture est indéfini, donc cette structure est potentiellement dangereuse et doit être généralement évitée: REAKTOR CORE – 75 � �� �� �� ���� � �� �� ���� � �� ����� � �� �� Une manière plus satisfaisante de réaliser la structure ci-dessus est la suivante: � �� �� �� ����� �� ����� �� ����� � �� �� �� Ou encore celle-là: � �� �� �� ���� � �� �� �� ����� � ����� �� �� Même si vous pensez qu’à un certain endroit, l’ordre relatif des opérations de lecture et d’écriture n’est pas important, imposer un certain ordre de traitement n‘est pas gênant et c‘est un peu plus sûr. L’ordre relatif des opérations d’écriture est important. L’ordre relatif des opérations de lecture importe peu, tant que leur ordre par rapport aux opérations d’écriture est bien défini. Les connexions OBC ne sont pas compatibles avec les connexions normales. De plus, les connexions OBC correspondant à des types d’objets différents ne sont pas compatibles entre elles. Les broches de types incompatibles ne peuvent pas être connectées, p.ex. vous ne pouvez pas connecter une sortie de signal normal à une entrée OBC. 76 – REAKTOR CORE 4.3. Initialisation Comme nous commençons à travailler avec des objets ayant un état interne (dans le cas des Read et Write, la mémoire partagée), il devient nécessaire de comprendre ce qu’est l’état initial de la structure que vous avez construite. Par exemple, si nous voulons lire la valeur dans une mémoire (au moyen d’un module Read) avant que quoi que ce soit n’y ait été écrit, quelle sera la valeur lue ? Et si la valeur par défaut ne nous convient pas, comment pouvons-nous la modifier ? Ces questions sont réglées par le méchanisme d’initialisation de Reaktor Core. L’initialisation des structures core est effectuée de la manière suivante: - d’abord, tous les états sont initialisés à des valeurs par défaut, généralement des zéros. En particulier, les mémoires partagées et toutes les valeurs de sortie des modules sont réglées sur zéro, à moins que vous ne l’ayez spécifié autrement ; - ensuite, un évènement d’initialisation est envoyé simultanément par toutes les sources d’initialisation. Les sources d’initialisation comprennent la plupart des modules qui n’ont pas d’entrée: les modules Const (y compris les QuickConsts), les entrées des cellules core, et certains autres. Les sources envoient généralement leur valeur initiale comme évènement d’initialisation, p.ex. les constantes envoient leurs valeurs, et les entrées des cellules core envoient les valeurs initiales reçues du niveau primaire, à l’extérieur. Si le module est une source d’évènement d’initialisation, vous en trouverez mention dans la section de référence des modules. Si le module n’est pas une source d’initialisation, il traite les évènements d’initialisation exactement comme n’importe quel autre évènement. La plupart des sources d’initialisation sont les modules qui n’ont pas d’entrée(s) et seulement ceux-ci. Observons le fonctionnement de l’initialisation avec l’exemple suivant: � �� ����� � �� ������ �� �� ���� � �� �� �� �� ���� � �� � REAKTOR CORE – 77 Ce n’est qu’une partie de la structure, le module Read sur la gauche est connecté à une source d’horloge (en anglais clock), qui envoie aussi un évènement d’initialisation (comme toute source d’horloge qui se respecte). Initialement, tous les signaux de sortie ainsi que l’état interne de la chaîne Read-Write-Read sont fixés à zéro. � �� �� ����� � �� �� �� ���� � ���� ���� �� �� �� �� ���� � ���� �� �� �� �� �� Puis un évènement d’initialisation est envoyé simultanément de la source d’horloge et de la constante 5. � �� ��� ����� � � � ����� �� ��� �� �� ���� � �� ��� �� �� ���� � ��� �� �� ��� Le module Read sur la gauche est traité avant le module Write et donc l’évènement d’horloge y arrive avant que la nouvelle valeur ne soit écrite dans la mémoire, donc la sortie de ce module Read est égale à zéro. Puis la nouvelle valeur est écrite dans la mémoire par le module Write. Maintenant, le second module Read est lancé, générant une valeur de 5 à sa sortie. Enfin, le module additionneur est traité et génère une somme de 5. Comme vous vous en souvenez, les entrées déconnectées sont traitées dans Reaktor Core comme des valeurs nulles (à moins qu’elles ne soient spécifiées autrement par un module particulier). Cela signifie que ces entrées reçoivent aussi un évènement d’initialisation, exactement comme si un véritable module de constante nulle y était connecté. 78 – REAKTOR CORE � ��� �� �� ��� ��� Ci-dessus, un additionneur avec une entrée déconnectée et une connectée à une constante reçoit deux évènements d’initialisation simultanés, l’un venant de la constante zéro “par défaut” et l’autre de la vraie connexion à une constante. Il peut aussi y avoir une signification spéciale aux entrées déconnectées qui ne sont pas des entrées de signal (elles ne peuvent donc pas être connectées à une constante nulle). Par exemple, une entrée maîtresse déconnectée d’un module Write signifie que la chaîne de la mémoire partagée démarre à cet endroit et continue avec les modules connectés à la sortie esclave. 4.4. Construire un accumulateur d’évènements Le module accumulateur d’évènements que nous voulons construire maintenant doit comporter deux entrées, l’une pour le valeurs d’évènements à accumuler, et l’autre pour remettre l’accumulateur à zéro. Il lui faut aussi une sortie qui envoie la somme totale des évènements accumulés. Nous allons construire ce module sous la forme d’une macro core. Une telle macro sera facile à utiliser à l’intérieur d’une cellule core évènement: L’intérieur de notre macro ressemble pour l’instant à ceci: REAKTOR CORE – 79 Le module accumulateur a besoin d’un état interne dans lequel il stockera la valeur somme des évènements accumulés. Nous allons utiliser les modules Read et Write pour construire la boucle de l’accumulateur. Vous les trouverez dans le sous-menu Built In Module > Memory: Le module que vous voyez à gauche (avec une flèche sortant du rectangle) est le module Read, et le module à droite (avec une flèche entrant dans le rectangle) est le module Write. En réponse aux évènements entrants, la boucle de l’accumulateur doit prendre l’ancienne valeur et lui ajouter la nouvelle. Nous allons donc utiliser le module Read pour récupérer l’ancien état, utiliser un additionneur pour y ajouter la nouvelle valeur et utiliser le module Write pour stocker la valeur en résultant. Veuillez noter que l’horloge du module Read est pilotée par l’évènement entrant, et que le module Write (relié au Read par une connexion OBC) est bien sûr situé en aval du premier, puisque nous voulons écrire après avoir lu. La structure ci-dessus accumule les valeurs entrantes et envoie en sortie le résultat de leur somme. Il ne manque plus que la fonction “reset” (le redémarrage) ainsi que la circuiterie pour définir l’état initial. 80 – REAKTOR CORE Penchons-nous d’abord sur la circuiterie de reset. Puisque nous sommes dans le monde de Reaktor Core, l’entrée “In” et la sortie “Rst” doivent envoyer un évènement simultanément. Si nous voulons que cette macro core soit utilisable dans des contextes divers et variés, nous devons en tenir compte. Supposons que les entrées “In” et “Rst” produisent simultanément un évènement. Que voulons-nous qu’il arrive dans ce cas ? Le reset doit-il logiquement survenir avant que l’évènement accumulé soit traité, ou après ? Ceci est très similaire à la différence entre les fonctions Latch et Z-1, qui différaient uniquement par l’ordre relatif de traitement de l’entrée du signal et de l’entrée de l’horloge. Nous suggérons l’approche du Latch, car ce module est très largement utilisé dans les structures Reaktor Core, et son comportement est donc plus intuitif. Dans un Latch, le signal d’horloge arrive logiquement après le signal de valeur. Dans notre cas, le signal de reset doit arriver logiquement après le signal accumulé (obligeant l’état et la sortie à prendre la valeur zéro). Nous devons donc, d’une façon ou d’une autre, “écraser” la sortie de l’accumulateur avec une valeur initiale. Pour ce faire, il nous faudra utiliser un nouveau concept que nous allons détailler maintenant. 4.5. Le mélange d’évènements Nous avons déjà abordé différentes manières de combiner deux signaux dans Reaktor Core, par exemple avec les opérations arithmétiques. Mais il nous manque toujours un moyen simple de mélanger deux signaux. Mélanger n’est pas additionner. Mélanger signifie prendre la dernière valeur de tous les signaux, et non les additionner. Pour mélanger les signaux, vous devez utiliser le module Merge (Mélanger en anglais...). Observons son fonctionnement. Imaginez un module Merge avec deux entrées. La valeur initiale de sortie (avant l’évènement d’initialisation) est bien sûr zéro, comme pour la plupart de modules: � �� �� ������ �� Maintenant, un évènement de valeur 4 arrive à la deuxième entrée du module: REAKTOR CORE – 81 � �� �� �� ������ ��� L’évènement traverse le module et apparaît à la sortie. Maintenant, la sortie du module mélangeur a pour valeur 4. Puis un autre évènement, de valeur 5, arrive à la première entrée: � �� �� �� ������ ��� L’évènement traverse le module et apparaît à la sortie, qui passe donc à la valeur 5. Maintenant, deux évènements avec les valeurs 2 et 8 arrivent simultanément aux deux entrées: � �� �� �� �� ������ ��� Là, nous devons appliquer au module Merge une règle spéciale: Des évènements simultanés arrivant aux entrées d’un module Merge sont traités dans l’ordre de numérotation des entrées. Il n’y a toujours qu’un seul évènement généré en sortie, car une sortie Reaktor Core ne peut produire plusieurs évènements simultanés. Dans le cas ci-dessus, l’évènement arrivant à la seconde entrée est traité après celui arrivant à la première, “écrasant” la valeur 2 par la valeur 8, qui est transmise (seule) à la sortie. 82 – REAKTOR CORE 4.6. L’accumulateur d’évènements avec reset et initialisation Pour réaliser la fonction “reset”, nous devons donc “écraser” la sortie de l’accumulateur par une certaine valeur initiale. Pour ce faire, nous pouvons utiliser le module Merge, que l’on trouve dans le sous-menu Built In Module > Flow. Un moyen simple est de connecter la seconde entrée du module mélangeur à l’entrée “Rst”. L‘événement de reset est désormais directement envoyé au module Merge, écrasant la sortie de l’additionneur même si un évènement accumulé arrive au même moment. De là, l’évènement est envoyé en sortie ainsi que dans l’état interne de l’accumulateur. Dans la structure ci-dessus, la valeur arrivant à l’entrée “Rst” est utilisée comme nouvelle valeur par l’accumulateur. Ce n’est peut-être pas une mauvaise idée, mais en tout cas il ne s’agit pas vraiment d’une fonction “reset” mais plutôt d’une fonction “set”, implémentée dans le module accumulateur standard de Reaktor. Si nous voulons une véritable fonction “reset”, nous devons écrire expressément un zéro dans l’état interne, quelle que soit la valeur apparaissant à l’entrée “Rst”. Nous devons donc envoyer une valeur zéro au module Write à chaque fois qu’un évènement arrive à l’entrée “Rst”. Envoyer un évènement avec une valeur particulière en réponse à un évènement entrant est une tâche assez commune dans Reaktor Core, et nous suggérons d’utiliser à cette fin une macro Latch, située dans Expert Macro > Memory > Latch: Comme nous l’avons décrit plus haut, le module Latch dispose d’une entrée de valeur (en haut) et d’une entrée d’horloge (en bas). Nous souhaitons connecter l’entrée “Rst” à l’entrée d’horloge du Latch et une constante nulle à son entrée REAKTOR CORE – 83 de valeur, car nous voulons envoyer uniquement des évènements de valeur zéro. Nous pouvons aussi nous rappeler que les entrées déconnectées sont considérées comme étant des constantes nulles (si rien d’autre n’est spécifié) et laisser l’entrée de valeur du Latch déconnectée: La fonction reset devrait maintenant fonctionner correctement. La dernière chose que nous devons effectuer est de nous assurer que l‘initialisation est correcte. Définissons tout d’abord ce qu’est une initialisation correcte. Regardons d’un peu plus près comment la structure ci-dessus va être initialisée. Supposons que l’évènement d’initialisation soit envoyé simultanément depuis les entrées “In” et “Rst” de la structure supérieure de la celllule core, ainsi que depuis la constante nulle implicite de l’entrée de valeur (déconnectée) du module Latch. Ce dernier, commandé par l’entrée “Rst”, va envoyer une valeur nulle à la seconde entrée du module Merge, écrasant toute valeur arrivant à la première entrée de celui-ci. Ainsi, un zéro est inscrit dans l’état interne et envoyé à la sortie: c’est parfait ! Cependant, cela pose un petit problème. Il est possible que l’évènement d’initialisation n’arrive pas à l’un des deux ports, voire aux deux. Ceci peut survenir si par exemple aucun évènement d’initialisation n’arrive à l’entrée correspondante de la cellule core, ou si cette macro est utilisée dans une structure Reaktor Core plus complexe qui ne reçoit pas non plus d’évènements d’initialisation à toutes ses entrées (nous verrons plus tard comment arranger cela). Nous devons donc apporter une dernière et ultime modification à notre structure, pour qu’elle soit plus “universelle”. Rendez-vous dans les propriétés du module Merge et fixez le nombre d’entrées à 3: 84 – REAKTOR CORE Désormais, même si aucun évènement d’initialisation n’arrive à l’entrée “Rst”, la constante nulle implicite à la troisième entrée (déconnectée) du Merge enverra tout de même un évènement d’initialisation, générant ainsi la sortie et l’état interne initial corrects. Observons donc son fonctionnement. Nous vous suggérons de construire la structure primaire suivante utilisant le module créé Event Accum: Le nombre de voix de l’instrument doit être réglé sur 1 et l’indicateur doit être réglé pour afficher une valeur et être toujours actif, comme dans l’exemple précédent. Le bouton doit être placé en mode Trigger (lancement). REAKTOR CORE – 85 Passez en mode Panel et observez les valeurs augmentant par pas de 1, toutes les secondes, et redémarrant à chaque pression du bouton. Profitons de cette occasion pour vous présenter le mode de déboguage de Reaktor Core. Comme vous l’avez probablement déjà remarqué, contrairement au niveau primaire de Reaktor, les valeurs à la sortie des modules ne s‘affichent plus lorsque vous laisser le curseur dessus. C’est un effet secondaire malheureux de l’optimisation interne de Reaktor Core, qui a pour effet que les valeurs à l’intérieur des structures Reaktor Core ne sont pas accessibles depuis l’extérieur. Comme nous vous entendons déjà gémir, nous avons opté pour un compromis. Vous pouvez désactiver l’optimisation pour une structure core particulière, ce qui vous permet de voir les valeurs de sortie. Essayons avec la structure que nous venons de construire. Faites un clic droit sur le fond et sélectionnez Debug Mode: 86 – REAKTOR CORE Vous pouvez également activer ce mode via le bout d’outils. dans la barre Maintenant, si vous maintenez votre curseur au-dessus d’une sortie particulière, vous verrez s’afficher la valeur de cette sortie (ou un intervalle de valeurs): Vous pouvez désactiver le mode de déboguage en sélectionnant à nouveau la même commande (ou en appuyant sur le même bouton): Le mode de déboguage est aussi automatiquement désactivé si vous sortez de la structure, vous devrez donc l’activer à nouveau pour toute autre structure. Après avoir “débogué” notre macro, il nous faut penser à l’enregistrer dans un fichier pour un usage ultérieur. Pour ce faire, effectuez un clic droit sur la macro et sélectionnez “Save As...”: REAKTOR CORE – 87 Comme avec les cellules core, vous avez la possibilité d’insérer vos propres macros dans le menu. Les macros doivent être placées dans le sous-dossier “Core Macros” du dossier utilisateur de Reaktor: Si des fichiers se trouvent dans ce dossier “Core Macros” ou ses sous-dossiers, un nouveau sous-menu apparaît dans le menu contextuel (menu du bouton droit): 88 – REAKTOR CORE Encore une fois, les mêmes restrictions que pour le dossier “Core Cells” s’appliquent au dossier “Core Macros”: - les dossiers vides n’apparaissent pas dans le menu, - ne placez jamais vos propres fichiers dans la librairie système, mais dans la librairie utilisateur. 4.7. Réparons le modeleur d’évènements Nous pouvons maintenant étudier plus en détail ce qui n’allait pas dans le modeleur d’évènements que nous avons construit auparavant: Le problème vient de l’évènement d’initialisation. Si vous observez comment l’initialisation se propage dans la structure ci-dessus, vous remarquerez les choses suivantes: - l’entrée ‘x’ envoie ou n’envoie pas d’évènement d’initialisation, selon qu’elle en reçoit un ou non de la structure primaire à l’extérieur de la structure (c’est la règle générale pour les évènements d’initialisation des entrées évènements des cellules core) ; - les constantes 4 et 0,25 envoient toujours des évènements d’initialisation. REAKTOR CORE – 89 De ce fait, si, pour une raison quelconque, l’évènement d’initialisation ne n‘arrive pas à l’entrée du modeleur, sa sortie continuera à recevoir l’évènement issu du dernier multiplicateur et transfèrera cet évènement à la structure du niveau primaire, à l’extérieur. Même si ceci n‘est pas trop grave pour le traitement du signal (si l’évènement d’initialisation en entrée fait défaut, l’entrée est considérée comme nulle et l’évènement d’initialisation de sortie est tout de même envoyé), ce n’est pas exactement ce que l’on attend intuitivement d’un module de traitement d’évènements. Nous préfèrerions plutôt que le module envoie un évènement en sortie uniquement en réponse à un évènement entrant. Nous sommes donc confrontés au problème suivant: nos modules de constantes peuvent envoyer des évènements à des moments indus (ie quand il n’y a pas d’évènement en entrée). Comme solution, nous suggérons de remplacer les modules de soustraction et de multiplication, qui ont des constantes en entrée, par leurs homologues à Modulation. Les macros à “Modulation” sont situées dans la librairie de Reaktor Core dans Expert Module > Modulation: L’appellation “Modulation”, même si elle n’est pas correcte à 100 %, reflète pourtant leur fonction, qui est d’utiliser un signal pour en moduler un autre (nous le verrons clairement plus tard, lorsque nous utiliserons des signaux de contrôle pour moduler des signaux audio dans des structures de bas niveau). La plupart de ces macros combinent deux signaux, un “porteur” et un “modulateur” (un peu comme dans la transmission radio). Contrairement aux 90 – REAKTOR CORE modules core arithmétiques d’usine, les “macros à modulation” génèrent un évènement de sortie uniquement en réponse à un évènement à l’entrée du signal “porteur”. Les évènements à l’entrée “modulateur” ne relancent pas le processus de calcul. L’implémentation interne des macros à modulation est très simple: elles retiennent juste le signal modulateur via un Latch, celui-ci étant régulé par le signal porteur. Voici l’exemple de la structure interne du “multiplicateur à modulation” (l’entrée appelée “a” est le modulateur): Nous remplaçons donc le module de soustraction par la macro à modulation a - x ainsi que le dernier module multiplicateur par la macro à modulation x mul a. Voici à quoi ressemble notre structure après ces modifications (nous avons également remplacé les modules Const par des QuickConst, mais c’est sans importance): Généralement, dans les macros à modulation, vous pouvez reconnaître l’entrée du modulateur grâce à l’icône de la macro (le petit dessin sur le module): la flèche de l’icône indique la position de l’entrée du modulateur. Dans le cas du module de soustraction, la flèche est en haut, donc l’entrée de modulation aussi. Pour le module de multiplication, c’est l’inverse. Notez également que la sortie de ces modules est située en face de l’entrée du porteur, ce qui est un autre indice. Enfin, vous pouvez placer votre curseur sur les modules et leurs entrées et lire les informations qui s’affichent. Dans la structure ci-dessus, aucun évènement ne sera envoyé, à moins qu’un évènement n’arrive à l’entrée de la cellule core: - le module “|x|” est directement commandé par l’évènement d’entrée de la cellule core ; REAKTOR CORE – 91 - le module de soustraction consécutif est uniquement commandé par la sortie du module “|x|”, qui envoie un évènement uniquement en réponse à un évènement d’entrée, la constante QuickConst n’ayant pas d’effet de commande ; - le premier multiplicateur est commandé soit par la sortie du module de soustraction, soit par l’évènement d’entrée de la cellule core, mais nous avons déjà vu que les deux ne peuvent survenir que simultanément ; - le second multiplicateur est commandé uniquement par l’évènement entrant et non par la constante QuickConst. Notre structure se comporte désormais de façon un peu plus intuitive. 5. Le traitement de l’audio en détail 5.1. Les signaux audio Dans Reaktor Core, les signaux audio ne sont pas d’un type particulier: l’audio est aussi un évènement, qui ne diffère en rien des autres évènements du point de vue de la structure. La seule différence est que, pour les signaux audio, les évènements sont produits “à des instants précis régulièrement espacés” correspondant au taux d’échantillonnage. Pour produire des évènements régulièrement espacés (ou tout autre suite d’évènements d’ailleurs), nous avons besoin d’une source d’évènements. Comme pour les cellules core évènements, les entrées des cellules core audio sont aussi des sources d’évènements. Mais nous avons maintenant un type d’entrée supplémentaire: Le Entrées Audio envoient régulièrement des évènements core à l’intérieur de la structure, à un rythme déterminé par le taux d’échantillonnage utilisé à l’extérieur, dans la structure du niveau primaire. Les évènements sont envoyés simultanément depuis toutes les entrées audio de la cellule core. Les entrées audio envoient également l’évènement d’initialisation dans la structure de la cellule core. Cet évènement est envoyé, quoi qu’il arrive dans la structure de niveau primaire. Mais la valeur envoyée par ces entrées pendant l’initialisation dépend, elle, du processus d’initialisation extérieur (dans la structure primaire). 92 – REAKTOR CORE Il existe aussi un nouveau type de sortie, utilisé à la place des sorties évènements: Les Sorties Audio envoient dans la structure extérieure de niveau primaire la dernière valeur reçue de la structure core intérieure. Comme les sorties audio du niveau primaire n’envoient pas d’évènements, aucun évènement n’est envoyé vers l’extérieur. Nous allons maintenant essayer de reconstruire le même modeleur que précédemment, mais en mode audio au lieu du mode évènement. Globalement, nous pouvons utiliser exactement la même structure, en remplaçant simplement les entrées et sorties évènements par leurs équivalentes audio: Vous pourriez vous demander pourquoi nous n’avons pas utilisé ici les macros à modulation. La raison en est que nous manipulons maintenant des signaux audio. Ceux-ci envoient toujours un évènement d’initialisation, nous sommes donc sûrs de sa présence aux entrées. Mais vous êtes libre d’utiliser des macros à modulation si vous préférez. Nous aurions aussi pu essayer d’insérer la structure ci-dessus dans une macro pour pouvoir la réutiliser dans d’autres structures Reaktor Core, pour le traitement des évènements comme pour celui de l’audio. Dans ce cas, il est conseillé d’utiliser ces fameuses macros à modulation, car il n‘est plus possible de savoir à l’avance quel type de signal sera traité par le module: Et voici la structure interne de la cellule core audio pour ce cas précis: REAKTOR CORE – 93 Pour la tester, nous allons la connecter à un oscillateur en dents de scie ainsi qu’à un oscilloscope. Vous trouverez un oscilloscope dans Insert Macro > Classic Modular > 00 Classic Modular – Display > Simple Scope (dans la structure primaire). N’oubliez pas de vous assurer que le nombre de voix est bien réglé sur 1. Nous utilisons le contrôle externe de l’oscilloscope pour une meilleure synchronisation aux taux élevés de distorsion (le bouton Ext du panneau de l’oscilloscope doit être activé). Modifiez l’intervalle du potentiomètre Ampl à environ [0.. 5] pour pouvoir observer le modelage. 5.2. Le bus d’horloge du taux d’échantillonnage Nous devons encore aborder au moins deux points pour pouvoir construire des structures audio. Le premier est la création des cellules core audio sans entrées audio. Bien sûr, nous pouvons les créer, mais comment faire pour obtenir une source d’évènements audio ? Le second point est que de nombreux algorithmes de traitement numérique du signal (DSP) nécessitent la connaissance du taux d’échantillonnage actuel. Nous allons ici traiter de ces deux sujets. Chaque structure Reaktor Core possède une connexion spéciale, appelée “sampling rate clock bus” (“bus d’horloge du taux d’échantillonnage”). Ce 94 – REAKTOR CORE bus (ou canal de transmission) transporte deux signaux: ceux de l’horloge et du taux d’échantillonnage (en anglais “clock” et “rate”). Clock est une source de signal dans laquelle des évènements sont régulièrement envoyés au taux d’échantillonnage audio. Comme avec tous les signaux audio standard, cette source envoie un évènement d’initialisation. Les évènements du signal d’horloge ont toujours une valeur nulle, mais les structures utilisant ce signal doivent ignorer ses valeurs car elles pourront être amenées à évoluer dans le futur. Rate est une source de signal dont les valeurs sont toujours égales au taux d’échantillonnage actuel, en Hertz. Les évènements sont envoyés depuis cette source lors de l’initialisation ou lors des modifications du taux d’échantillonnage. Vous accédez au bus du taux d’échantillonnage via un clic droit sur n’importe quelle entrée de signal et en sélectionnant Connect to SR.C pour le signal d’horloge, ou Connect to SR.R pour le signal de taux d’échantillonnage. La connexion s‘affiche à côté de l’entrée: Le bus d’horloge du taux d’échantillonnage ne fonctionne pas à l’intérieur des cellules core évènements. 5.3. Réinjection d’une connexion Comme nous l’avons déjà vu, les règles concernant l’ordre de traitement ne peuvent s’appliquer si la structure contient une ou plusieurs réinjections. C’est pourquoi nous avons besoin de règles supplémentaires qui définissent le traitement des réinjections. REAKTOR CORE – 95 La regle principale est: lLes structures Reaktor Core ne savent pas manipuler la réinjection. Non, pas tout à fait comme ça. Vous pouvez effectuer des connexions de réinjection dans Reaktor Core. Mais comme le moteur de Reaktor Core ne sait pas manipuler les structures avec réinjection, il va les résoudre. Résoudre une réinjection signifie que votre structure est modifiée (en interne, vous ne verrez rien à l’écran) de façon à supprimer la réinjection. Si jamais vous ne le saviez pas, la réinjection sans délai n’est pas pensable dans le monde numérique. Il doit y avoir un délai d’au moins un échantillon dans le chemin de réinjection. Et c’est justement ce que Reaktor Core va faire pendant la résolution de la réinjection: le moteur va introduire un module de délai d’une durée égale à un échantillon (Z^-1) dans le chemin de réinjection. Comme vous le savez déjà, les ports où les délais implicites ont été insérés par Reaktor Core sont indiqués par un grand Z orange: Nous avons déjà vu une structure basée sur un module Read et un module Write réalisant cette fonctionnalité Z^-1. Essayons de placer une telle construction de Read et Write dans notre structure. Nous allons la placer sur le câble de la réinjection: D’abord on écrit, puis on lit (notez que le module Read est piloté par l’horloge 96 – REAKTOR CORE SR.C pour s’assurer que la lecture est effectuée une fois par cadence audio). Ainsi, la valeur lue a toujours un échantillon de décalage avec la valeur écrite. Et il n’y a pas de réinjection dans la structure. Vous n’en êtes pas sûr(e) ? D’accord, déplaçons un peu les modules (sans toucher aux connexions): Vous êtes d’accord maintenant ? Évidemment ! En insérant un module Z^-1, on supprime formellement la réinjection de la structure, tout en la conservant, logiquement parlant (avec un délai d’un échantillon audio). En fait, la structure interne d’une macro Z^-1 est un peu plus compliquée qu’une simple paire de Read et Write. Nous verrons ceci plus en détail dans la section suivante. Vous n’avez aucune influence sur l’endroit où la résolution automatique de réinjection va être insérée. Elle est insérée sur n’importe quel câble de la boucle de réinjection. Il n’est même pas garanti que cette résolution soit toujours placée sur le même câble: elle peut changer dans la prochaine version du logiciel, ou en réponse à une autre modification quelque part dans la structure, elle peut même être différente la prochaine fois que vous chargerez cette structure depuis le disque dur. Cette résolution automatique de la réinjection est conçue pour les structures pour lesquelles l’endroit exact de la résolution n’a pas d’importance. En particulier, ceci est bien pratique pour les utilisateurs pas vraiment calés en traitement numérique de signal et ayant du mal à envisager de telles problématiques. La résolution automatique de réinjection leur permet d’obtenir des résultats satisfaisants. Si vous avez besoin d’un contrôle précis sur les points de résolution de réinjection, vous pouvez insérer explicitement des modules Z^-1 dans vos structures. Ces modules élimineront formellement les réinjections et aucune résolution interne ne sera nécessaire. Voici une version de la structure ci-dessus, avec une macro Z^-1 insérée (elle REAKTOR CORE – 97 se trouve dans le sous-menu Expert Macro > Memory): Comme vous pouvez le voir, le gros Z orange a disparu, et vous pouvez également constater que le point de délai d’un échantillon n’est plus au même endroit que celui qui avait été automatiquement inséré: ce dernier était sur le câble allant de la sortie de l’additionneur à l’entrée du multiplicateur, alors qu’il est maintenant sur le câble entre la sortie du multiplicateur et l’entrée de l’additionneur. La raison d‘être de la seconde entrée du module Z^-1 sera expliquée plus loin. Vous la laisserez généralement déconnectée. La réinjection sur les connexions OBC et sur tous les autres types de connexions “non-signal” (introduites plus loin) n’a pas de sens, c’est pourquoi elle n’est pas permise. Si une boucle de réinjection sans câble de signal apparaît, une des connexions est indiquée comme invalide et considérée comme absente. La marque “invalide” est symbolisée par une croix rouge sur le port: En revanche, les boucles de réinjection contenant des types “mixes” de connexions, ie avec des câbles transportant du signal et d’autres types de câbles, sont tout-à-fait acceptées et sont résolues de la manière habituelle, la résolution étant insérée sur l’un des câbles “normaux” (ie transportant du signal): 98 – REAKTOR CORE En fait, cela signifie que les connexions non-signal ne sont pas affectées par la résolution de réinjection, à moins de faire une boucle de réinjection entièrement sans signal, ce qui n‘est pas palpitant. 5.4. Réinjection et macros De manière générale, en ce qui concerne la résolution des réinjections, les macros sont traitées comme les modules d’usine. Considérons une macro qui transfère juste le signal d’entrée en sortie. Voici sa structure interne: Supposons maintenant que nous construisons une structure avec réinjection en utilisant cette macro: La boucle de réinjection passe par deux câbles dans la structure ci-dessus, ainsi que par un câble à l’intérieur de la macro. Où la résolution va-t-elle se produire ? (d’accord, on peut voir sur la figure ci-dessus qu’elle se produit à l’entrée de l’additionneur dans ce cas particulier, mais nous savons qu’elle aurait pu se produire ailleurs). Imaginez un instant que Thru ne soit pas une macro mais un module d’usine. Dans ce cas, il est évident que la résolution de la réinjection ne peut pas apparaître dans ce module, mais uniquement à l’extérieur. Nous nous efforçons de rendre les macros aussi semblables aux modules d’usine que possible. Pour cette raison, par défaut, la résolution d’une telle boucle de réinjection aura lieu à l’extérieur de la macro. L’endroit exact n’est pas spécifié, mais on sait que ce sera à l’extérieur de la macro Thru. La règle générale est la suivante: la résolution de la réinjection apparaît dans le niveau de structure le plus élevé de la boucle de réinjection. REAKTOR CORE – 99 Vous pouvez cependant modifier ce comportement par défaut, c’est-à-dire autoriser la résolution de réinjection à l’intérieur des macros. En fait, vous auriez déjà pu vous demander, si les macros sont vraiment traitées comme les modules d’usine, comment une macro Z^-1 peut-elle résoudre une réinjection. En effet, considérons la structure suivante: Si les macros et les modules d’usine étaient équivalents, rien ne devrait changer lorsque l’on remplace le multiplicateur par une macro Z^-1: Mais cette structure est différente, car la réinjection implicite a disparu. Cette macro Z^-1 doit bien avoir quelque chose de spécial... et en effet, elle a quelque chose de spécial. Si nous regardons à l’intérieur de cette macro, nous y voyons presque la même structure que celle de notre propre implémentation de la fonction Z^-1 (cf. plus haut): 100 – REAKTOR CORE Comme vous pouvez le constater, l’entrée d’horloge de la macro est connectée au module Read interne. La connexion par défaut pour cette entrée n’est pas une constante nulle mais l’horloge audio, car c’est ce dont vous avez besoin dans la plupart des cas. Le module connecté entre l’entrée supérieure et le module Write sera expliqué plus loin. Nous pouvons l’ignorer pour l’instant. Jusque là, rien de spécial dans cette structure, si ce n’est qu’elle semble réaliser la fonction Z^-1 dont nous avons déjà parlé. Pourtant, comment le moteur de Reaktor Core sait-il que cette structure sert à résoudre les boucles de réinjection ? Bien sûr, le moteur sait que cette structure peut résoudre les boucles de réinjection, mais quant à savoir si elle est prévue pour ? Ceci est géré par les propriétés de la macro, et plus particulièrement par le réglage Solid de la macro: Cette propriété dit au moteur de Reaktor Core si la macro doit être considérée comme un module d’usine “solide” pour la résolution de réinjection, ou si elle doit être considérée comme transparente. Dans 99 % des cas, vous conserverez cette propriété activée. En effet, vous ne souhaiterez généralement pas que la résolution de réinjection apparaisse à l’intérieur de vos macros. REAKTOR CORE – 101 Une bonne raison à cela est que la résolution se produisant à l’intérieur d’une macro passe inaperçue, à moins d’ouvrir la structure interne de cette macro, d’où le risque que certains délais implicites de réinjection échappent à votre attention. Par exemple, si nous prenons notre structure avec la macro Thru, et si nous désactivons le réglage Solid (assurez-vous de modifier ce réglage pour la bonne macro, vous pouvez le vérifier via le texte “Thru” apparaissant dans le champ de nom des propriétés): Assurez-vous de modifier la bonne macro Désactivez le réglage Solid Votre structure externe est probablement toujours la même (nous disons “probablement”, car on ne sait jamais où se trouve la résolution de réinjection): Mais si vous modifiez votre structure en connectant la sortie à un autre module, elle pourrait bien ressembler à ceci: 102 – REAKTOR CORE Notre délai de résolution de réinjection semble avoir disparu. Dans une structure plus grande et plus complexe, nous pourrions facilement oublier qu’il y a un délai implicite. Où est passé le délai ? Bien sûr, il est maintenant dans la macro, le seul endroit que nous ne pouvons voir de l’extérieur: Une deuxième bonne raison pour conserver la propriété Solid activée est que, dans certains cas, si vous la désactivez, la fonction de la macro peut être modifiée une fois la macro placée dans la boucle de réinjection. Bref, facilitez-vous la vie et ne désactivez cette propriété que si vous construisez des macros spécifiquement conçues pour résoudre les réinjections… ce qui ne devrait pas arriver tous les quatre matins ! Revenons à notre module Z^-1. Comme la propriété Solid est désactivée pour cette macro, les limites de cette macro sont complètement transparentes pour la résolution de la réinjection. Ainsi, la macro Z^-1 n’est pas vraiment traitée comme un module d’usine et elle peut résoudre la réinjection de la manière décrite plus haut dans ce texte. 5.5. Les valeurs dénormales Dans les structures que nous avons construites jusqu’à présent, à l’intérieur de l’ordinateur, les valeurs des signaux sont représentées par des données binaires d’un type particulier, appelées les nombres à virgule flottante, en bref les flottants. Ce type de données permet une représentation efficace d’un grand éventail de valeurs. Le terme nombres à virgule flottante n’indique pas exactement comment les nombres sont représentés. Cette appellation décrit simplement l’approche utilisée pour les représenter, laissant une grande marge de manœuvre quant à leur implémentation. REAKTOR CORE – 103 Les processeurs équipant les ordinateurs personnels d’aujourd’hui utilisent la norme standard de virgule flottante de l’IEEE (Institute of Electrical and Electronics Engineers). Ce standard définit exactement comment les nombres à virgule flottante doivent être représentés et ce que doivent être les résultats des opérations entre eux (p.ex. comment manipuler les limitations de précision, etc.). En particulier, ce standard dit que, pour un groupe de valeurs à virgule flottante particulièrement petites qui, pour des raisons de précision limitée, ne peuvent être représentées correctement de la façon “normale”, un autre type de représentation doit être utilisée. Cette autre représentation est appelée “dénormale” (traduction directe de l’anglais “denormal”, terme utilisé uniquement dans cette acception et ce contexte – NdT). Pour une virgule flottante en 32-bit, l’intervalle des valeurs “dénormales” est approximativement de 10-38 à 10-45 et de -10-38 à -10-45. Les valeurs plus petites que 10 -45 en valeur absolue ne peuvent être représentées et sont considérées comme nulles. Comme ces nombres ont une représentation quelque peu différente de celle des nombres “normaux”, certains processeurs ont des difficultés à les manipuler. En particulier, les opérations sur ces nombres peuvent être parfois effectuées beaucoup, beaucoup plus lentement (dix fois, voire pire...) que les opérations sur les nombres “normaux”. Une situation classique dans laquelle les nombres dénormaux apparaissent pour des durées prolongées est celle des valeurs exponentiellement décroissantes, comme dans les filtres, certaines enveloppes et autres structures de réinjection. Dans de telles structures, après que le signal d’entrée est revenu à zéro, les signaux décroissent asymptotiquement vers zéro. Asymptotiquement signifie que ces signaux se rapprochent indéfiniment du zéro, sans jamais l’atteindre. Dans cette situation, les nombres dénormaux peuvent apparaître et rester dans la structure pendant un certain temps, entraînant une augmentation significative de l’utilisation du processeur. Les nombres dénormaux peuvent également apparaître lorsque vous modifiez la précision d’un flottant d’une valeur élevée (64-bit) à une valeur plus faible (32-bit). En effet, une valeur de 10-41 n’est pas dénormale lorsqu‘elle a une précision de 64 bits, mais le devient avec 32 bits (le changement de précision des flottants sera discutée plus loin). 104 – REAKTOR CORE Considérons la modélisation d’un filtre passe-bas analogique à 1 pôle avec une fréquence de coupure fixée à 20 Hz. Nos valeurs de signal numérique correspondent aux tensions analogiques en volts. Imaginons que le niveau du signal d’entrée est égal à 1 V (volt) sur une durée assez longue. La tension à la sortie du filtre est aussi égale à 1 V. Maintenant, nous passons brusquement la tension d’entrée à zéro. La tension de sortie va décroître selon la loi: Vout V0e 2� f ct où f c est la fréquence de coupure du filtre (en Hertz), t est le temps (en secondes) et la tension initiale. La tension de sortie va évoluer comme suit: après après après après 0,5 sec 0,6 sec 0,7 sec 0,8 sec Vout ≈10 -29 volt Vout ≈10 -33 volt Vout ≈10 -38 volt Vout ≈10 -44 volt Oups... les nombres entre 10 -38 et 10 -45 sont dans l’intervalle des valeurs dénormales. Donc, entre 0,7 et 0,8 secondes à peu près, notre tension est représentée par une valeur dénormale. Et ce pas seulement dans le filtre: la sortie du filtre est probablement traitée plus loin par la structure en aval, ce qui oblige aussi les modules suivants à traiter ces valeurs dénormales. Au taux d’échantillonnage de 44,1 kHz, l’intervalle de temps de 0,1 seconde correspond à 4410 échantillons. En supposant que la taille de tampon ASIO classique est de quelques centaines d’échantillons, nous devons produire de nombreux tampons réclamant une grosse utilisation du processeur (puisque tous ces tampons sont remplis de valeurs dénormales). Si le traitement de ces tampons nécessite une utilisation processeur de près de 100 % (ou plus), des clics audio apparaissent. De ces considérations, vous devez tirer l’enseignement suivant: les valeurs dénormales sont très mauvaises pour l’audio en temps réel... Les modules du niveau primaire de Reaktor sont programmés pour surveiller les valeurs dénormales susceptibles de survenir en leur sein. Pour ce faire, les algorithmes de DSP (traitement numérique du signal) ont été modifiés afin qu’ils produisent le moins de valeurs dénormales possible. Si vous concevez vos propres structures de bas niveau dans Reaktor Core, vous devez aussi REAKTOR CORE – 105 tenir compte de ces valeurs dénormales. Pour vous aider dans cette tâche, nous avons conçu le module Denormal Cancel, disponible dans le sous-menu Built In Module > Math: Le module Denormal Cancel dispose d’une entrée et d’une sortie. Il essaie de modifier légèrement la valeurs entrante pour éviter qu’une valeur dénormale n’arrive à la sortie: La manière dont ce module modifie le signal n’est pas fixe, elle peut varier d’une version de l’application à l’autre, voire d’un endroit à l’autre dans une structure. Actuellement, cette opération est effectuée en additionnant une toute petite constante à la valeur d’entrée. À cause de la limitation en précision, cette addition ne modifie pas les valeurs suffisamment grandes (les valeurs plus grandes que 10 -10 ne sont pas modifiées du tout). À cause de cette même limitation en précision, il est aussi très improbable que le résultat de l’addition soit une valeur dénormale (dans la plupart des cas, c’est même impossible). Si, pour quelque raison que ce soit, le module Denormal Cancel ne fonctionne pas pour votre structure, vous êtes évidemment libre d’utiliser vos propres techniques d’élimination des valeurs dénormales. Mais une technique fonctionnant sur une plateforme peut ne pas fonctionner sur une autre. Notre algorithme DN Cancel s’adapte à chaque plateforme gérée. Il est donc conseillé d’utiliser le module DN Cancel autant que faire se peut. Nous allons même réfléchir à la construction d’algorithmes alternatifs dans ce module – vos contributions sur notre forum sont les bienvenues ! 106 – REAKTOR CORE Certains processeurs proposent l’option de contourner le standard IEEE en désactivant la production de nombres dénormaux, forçant le résultat à valoir zéro. Cette option est parfois disponible, parfois non. Comme les structures Reaktor Core sont censées être indépendantes de la plateforme, il est fortement recommandé de vous occuper vous-même de l’élimination des valeurs dénormales dans vos structures, même si votre système particulier s’en occupe déjà. Comme les situations les plus classiques d’apparition de nombres dénormaux sont les boucles de réinjection exponentiellement décroissantes, et comme en traitement du son la plupart des boucles de réinjection décroissent exponentiellement (p.ex. les filtres et les structures à réinjection avec retards), nous avons décidé d’insérer l’élimination des valeurs dénormales dans la macro standard Z^-1. Comme vous vous en souvenez, l’intérieur de cette macro ressemble à ceci: Vous pouvez maintenant expliquer à quoi sert le module Denormal Cancel (DNC). Comme vous allez souvent utiliser la macro Z^-1 dans des structures à réinjection, il y a une forte probabilité que des valeurs dénormales y apparaissent. C’est pourquoi nous avons décidé de mettre ce module DNC directement dans la structure de la macro Z^-1. Il existe une autre version de cette macro, nommée Z^-1 ndc, qui n’effectue pas cette élimination des valeurs dénormales (ndc pour no denormal cancel). Vous pouvez l’utiliser dans les structures pour lesquelles vous êtes certain(e) qu’elles ne produisent pas de valeurs dénormales (par exemple les filtres FIR – à Réponse Impulsionnelle Finie): REAKTOR CORE – 107 5.6. Les autres mauvais nombres Les nombres dénormaux ne sont pas les seuls nombres méchants qui peuvent s’infiltrer dans vos structures à état interne, en particulier les boucles de réinjection. Il existe d’autres types de mauvais nombres: les INF, les NaN et les QnaN. Nous n’allons pas détailler chacun d’eux, une somme conséquente d’informations les concernant est déjà disponible, notamment sur Internet. L’important pour nous est d’éviter que ces nombres n’apparaissent dans nos structures. Généralement, de telles valeurs sont le résultat d’opérations invalides. Une division par zéro est le cas le plus évident. D’autres cas entraînent l’apparition de nombres trop grands pour être représentés par des virgules flottantes (ceux au-dessus de 10 -38 en valeur absolue), ou allant au-delà de l’intervalle raisonnable pour une opération particulière. De tels nombres ont tendance à se répandre dans les structures, plus encore que les nombres dénormaux. Par exemple, dès que vous ajoutez une valeur normale à une valeur dénormale, le résultat sera non-dénormal (bref normal), à moins que la deuxième valeur soit presque dénormale. En revanche, si vous ajoutez une valeur normale à INF, le résultat sera toujours INF. En plus de cette tendance à se répandre pour toujours dans les structures (... jusqu’au prochain reset de la structure), ces nombres ont la fâcheuse habitude d’utiliser beaucoup plus de temps de calcul sur certains processeurs. C’est pourquoi il nous faut tout faire pour tenter de prévenir leur apparition. “Tout faire” signifie par exemple de vérifier, à chaque fois que vous divisez un nombre par un autre, qu’aucune division par zéro ne puisse survenir. La phase d’initialisation requiert une attention toute particulière. Considérons par exemple l’élément de structure suivant: Si, pour une raison quelconque, l’évènement d’initialisation n’arrive pas à l’entrée inférieure du module diviseur, il en résulte une division par zéro lors du processus d’initialisation. Dans ce cas, il peut être utile d’utiliser à la place une macro à modulation, ou carrément de trouver une autre solution, selon vos besoins. 108 – REAKTOR CORE 5.7. Construction d’un filtre passe-bas à 1 pôle Un filtre passe-bas simple à 1 pôle peut être construit en utilisant l’équation: y=b*x+(1-b)*y-1 où x est l’échantillon d’entrée, y est le nouvel échantillon de sortie, y-1 est l’échantillon de sortie précédent et b est le coefficient définissant la fréquence de coupure du filtre. La valeur du coefficient b peut être prise égale à la fréquence de coupure cyclique normalisée, qui peut être calculée à partir de la formule: Fc = 2*π*fc / fSR où fc est la fréquence de coupure désirée (en Hertz), fSR est le taux d’échantillonnage (en Hertz), π est 3,14159… Fc est la fréquence de coupure cyclique normalisée (en radians pour les curieux). En fait, le coefficient b est égal seulement approximativement à la fréquence de coupure normalisée, l’erreur augmentant avec les hautes fréquences de coupure. Mais, pour nos besoins, cela devrait faire l’affaire, en particulier si nous n’avons pas besoin d’un réglage précis de la fréquence de coupure de notre filtre. Commençons par créer une cellule core audio avec deux entrées: l’une pour l’entrée audio et l’autre pour la fréquence de coupure. Dans cette version du module, nous allons utiliser une entrée évènement pour la fréquence de coupure. Prenons la bonne habitude de construire nos structures Reaktor Core en tant que macros core, pour pouvoir les réutiliser plus facilement. Nous allons aussi créer notre filtre en tant que macro. Créons donc une macro à l’intérieur de la cellule et créons les mêmes entrées pour la macro: REAKTOR CORE – 109 Construisons maintenant la circuiterie pour convertir la fréquence de coupure en coupure cyclique normalisée: 6.28319 est le 2*π, qui est ensuite divisé par le taux d’échantillonnage pour former la valeur à multiplier avec la fréquence de coupure. Nous n’avons pas besoin d’un multiplicateur “à modulation”, car “F” est logiquement une entrée de signal de contrôle, nous effectuerons donc la multiplication initiale même s’il n’y a pas d’évènement d’initialisation à l’entrée “F”. Nous effectuons la division avant la multiplication car la division est une opération relativement lourde, et le taux d’échantillonnage ne change pas si souvent que cela. Si seule la fréquence de coupure change, aucun évènement n’est envoyé au module diviseur et ainsi la division ne doit pas être à nouveau effectuée. Ceci est un exemple d’optimisation standard pouvant être réalisée par le concepteur de la structure core. Construisons la circuiterie réalisant l’équation du filtre: Au cas où des évènements asynchrones arriveraient à l‘horloge audio standard, l‘entrée audio est contrôlée par un Latch. Ceci ne serait pas nécessaire dans une structure de cellule core pour laquelle nous savons que l’entrée audio envoie les évènements aux instants corrects. Mais, de façon générale, cette pratique reste toujours une bonne idée. 110 – REAKTOR CORE On utilise deux multiplicateurs à modulation pour empêcher que l’entrée “F” (qui peut, dans l’absolu, changer de valeur à tout instant) ne lance le calcul dans la boucle de réinjection. L’appellation “macros à modulation” devrait maintenant être plus claire: ici, le signal issu de la fréquence de coupure sert à moduler les gains de la boucle de réinjection. L’utilisation du Latch est une technique standard de Reaktor Core pour s’assurer que les évènements entrants ne relancent pas le calcul de façon intempestive. Elle est également largement employée par les macros à modulation et dans d’autres situations semblables. Le module Z^-1 sert à enregistrer la valeur de la sortie précédente et envoie automatiquement un évènement avec cette valeur à chaque battement de la cadence audio. Le module prévient aussi l’apparition éventuelle de valeurs dénormales. Les utilisateurs habitués au traitement numérique du signal devraient remarquer que la structure ressemble beaucoup aux diagrammes de filtres DSP standard. Le module Merge (Mélangeur) situé à la sortie de l’additionneur garantit que l’état du filtre est toujours à zéro après l’initialisation, même si le signal d’entrée a une valeur non nulle à cet instant. N’oubliez pas de placer le convertisseur pitch-vers-fréquence dans la structure de la cellule core, et vous êtes prêt(e) pour le test: Nous suggérons d’utiliser la structure de test suivante (n’oubliez pas de régler la polyphonie de l’instrument sur 1 voix): Le potentiomètre Cutoff (Fréquence de coupure en anglais) doit être réglé dans l’intervalle [0.. 100]. Faites attention aux fréquences de coupure trop élevées: en raison de l’erreur croissante sur le coefficient du filtre, le filtre devient instable aux hautes fréquences. REAKTOR CORE – 111 Un meilleur design du filtre limiterait au moins les valeurs de la fréquence de coupure à l’intervalle pour lequel le filtre est stable. Dans notre cas, il faudrait limiter le coefficient b à l’intervalle [0.. 0,99] ou quelque chose comme ça. Les techniques de limitation des valeurs seront décrites plus loin dans ce texte. Voici ce que vous devriez désormais voir en mode Panel: Déplacez le potentiomètre de la fréquence de coupure (Cutoff) et observez l’évolution de la forme du signal. 6. Le traitement conditionnel 6.1. Le routage des évènements Dans Reaktor Core, les évènements ne doivent pas systématiquement voyager par les mêmes chemins. Il est possible de modifier dynamiquement ces chemins. Pour ce faire, vous pouvez utiliser le module Router (Built In Module > Flow > Router): Le module Router reçoit des évènements à son entrée signal (celle du bas) et les envoie soit vers sa sortie 1 (supérieure), soit vers sa sortie 0 (inférieure). La sortie vers laquelle les évènements sont envoyés dépend de l’état courant du routeur, contrôlé par l’entrée Ctl (l’entrée du haut). 112 – REAKTOR CORE L’entrée Ctl reçoit une connexion d’un nouveau type, compatible ni avec les signaux normaux, ni avec les signaux OBC. Il s’agit d’un signal de type BoolCtl (“boolean control”, “contrôle binaire” en anglais). Le signal BoolCtl ne peut être que dans l’état true ou l’état false (vrai ou faux, on ou off, 1 ou 0...). Si le signal de contrôle est dans l’état true, les évènements sont envoyés à la sortie 1. Si le signal de contrôle est dans l’état false, les évènements sont envoyés à la sortie 0. Dans Reaktor Core, les signaux de contrôle ont une différence notable avec les signaux normaux: ils ne transmettent pas d’évènements et de peuvent donc piloter seuls aucun traitement. Pour contrôler un routeur, vous avez bien sûr besoin d’une source de signal de contrôle. La source la plus commune est sans doute le module Comparison, disponible dans Built In Module > Flow > Compare: Ce module compare les deux signaux d’entrée et transmet le résultat sous la forme d’un signal BoolCtl. L’entrée supérieure est supposée être à gauche du signe de comparaison et celle du bas à droite du signe. Le module affichant ‘>’ produit donc un signal de contrôle true si la valeur à l’entrée supérieure est plus grande que celle à l’entrée inférieure, et un signal false dans le cas contraire. Vous pouvez changer le critère de comparaison dans les propriétés du module: REAKTOR CORE – 113 Les critères disponibles sont: = égal != différent (≠) <= inférieur ou égal (≤) < strictement inférieur >= supérieur ou égal (≥) > strictement supérieur Il est bien sûr possible de connecter plusieurs routeurs au même module de comparaison. Ils changeront d’état simultanément. Le module Router sépare le chemin d’évènements en deux branches. Assez souvent, ces branches se rejoignent en aval: En fonction du résultat de la comparaison, la structure ci-dessus va soit inverser le signal d’entrée, soit le laisser inchangé. Une implémentation alternative de cette structure est possible: Dans cette version, la sortie 0 du Router est déconnectée, le routeur fonctionne donc comme un interrupteur (ou un gate), laissant passer les évènements seulement s’il est dans l’état true. La valeur inversée arrive alors à la deuxième entrée du module Merge (mélangeur), écrasant la valeur non inversée qui arrive toujours à la première entrée. Si le routeur est dans l’état false, l’inverseur ne reçoit pas d’évènement et n’envoie rien à la seconde entrée du Merge, qui transmet donc le signal non modifié à sa sortie. Les branches sont le plus souvent mélangées avec un module Merge. Mais, théoriquement, vous pourriez utiliser à la place n’importe quel autre module (p.ex. un module arithmétique comme l’additionneur, le multiplicateur, etc.). 114 – REAKTOR CORE Les routeurs traitent l’évènement d’initialisation exactement comme les autres évènements. Ainsi, en utilisant des routeurs, on peut filtrer l’évènement d’initialisation pour l’empêcher d’apparaître dans certaines parties de la structure. 6.2. Construction d’un limiteur de signal Construisons la structure d’une macro Reaktor Core qui limitant le signal audio à un niveau spécifié): Si le signal d’entrée est inférieur au seuil, il est envoyé à la sortie 0 du routeur puis, via le module Merge, à la sortie de la structure. Sinon, le signal est envoyé à la sortie 1 où il contrôle le loquet (Latch), envoyant au module Merge la valeur seuil à la place du signal. La même chose se produit lors de l’initialisation. Veuillez remarquer que la sortie de cette structure ne change pas automatiquement quand le seuil change. Le nouveau seuil sera simplement utilisé pour tous les évènements ultérieurs de l’entrée de signal. Ceci est assez similaire au comportement des macros à modulation, pour lesquelles les changements du modulateur ne produisaient pas d’évènements de sortie. Voici une structure permettant de tester le module limiteur que nous venons de construire (une cellule core audio est utilisée): Et voilà ce que vous voyez sur le panneau: REAKTOR CORE – 115 En fait, vous trouverez un grand nombre de macros de limiteurs “à modulation” de ce genre dans le menu Expert Macro > Clipping. 6.3. Construction d’un oscillateur en dents de scie simple Construisons maintenant un simple oscillateur en dents de scie qui génère une forme d’onde en dents de scie d’amplitude 1 à une fréquence spécifiée. Nous allons utiliser l’algorithme suivant: “Augmente le niveau de sortie à une vitesse constante et, dès qu’il dépasse 1, rabaisse-le de 2”. On pourrait également proposer de réinitialiser le niveau à –1 au lieu de le rabaisser de 2, mais c’est généralement une mauvaise idée car nous pourrions difficilement maintenir la fréquence d’oscillation demandée. La vitesse de croissance du signal définit la fréquence de l’oscillateur selon l’équation suivante: d = 2f / fSR où d est l’augmentation du niveau pour un échantillon audio, f la fréquence de l’oscillateur et fSR le taux d’échantillonnage. Nous allons d’abord construire la circuiterie qui traitera cette vitesse de croissance: Nous avons maintenant besoin de la boucle d’incrémentation. Il est plus que temps d’utiliser les modules Read et Write exactement comme nous l‘avons fait précédemment avec l’accumulateur: 116 – REAKTOR CORE Le module Read lance l’incrémentation du niveau à chaque évènement audio. La somme de l’ancien niveau et de l’incrément est ensuite comparée à 1 et envoyée soit directement à l’écriture du résultat, soit à la circuiterie de bouclage. La troisième entrée du module Merge assure l’initialisation correcte de l’oscillateur à zéro. Théoriquement, le module qui soustrait 2 au niveau du signal devrait être une macro à modulation, mais cela nous importe peu ici, puisque le Merge écrase de toute façon le résultat de l’initialisation. Voici la structure de test que nous vous suggérons (n’oubliez pas le convertisseur P2F à l’intérieur de la cellule core): Et voilà la vue en mode Panel: REAKTOR CORE – 117 7. Les autres types de signaux 7.1. Les signaux flottants Le type de signal le plus couramment utilisé en DSP (traitement numérique du signal) sur les ordinateurs personnels modernes est la virgule flottante (ou flottant pour faire court). Les valeurs flottantes peuvent représenter une large gamme de valeurs, jusqu’à 1038 (en mode 32-bit) voire même 10308 (en mode 64-bit). Aussi utiles soient-elles, les virgules flottantes ont un inconvénient: elles sont d’une précision limitée. La précision est plus élevée en mode 64bit, mais elle reste limitée. La précision des valeurs en virgules flottantes est limitée pour des raisons techniques: si elles n’étaient pas limitées, ces valeurs nécessiteraient une quantité infinie de mémoire pour les stocker. C’est pour la même raison que vous ne pouvez pas écrire la représentation décimale complète d’un nombre transcendental (comme π) sur une feuille de papier “finie”, aussi grande soit-elle. Même si vous connaissiez tous les chiffres après la virgule (mais comment le pourriez-vous, puisqu’il y en a un nombre infini, mais même si vous le pouviez), essayez juste de les écrire tous: 3, 1, 4, 1, 5, 9, etc. Il arrivera un moment où vous manquerez de papier. Le traitement de tels nombres aurait également demandé un processeur infiniment rapide. Les signaux et l’espace mémoire que vous avez utilisés jusqu’ici sont représentés par des nombres en virgules flottantes en 32-bit. Reaktor Core vous offre la possibilité d’utiliser des flottants en 64-bit au cas où vous auriez besoin d’une précision supérieure (ou d’un intervalle de valeurs plus grand, bien qu’il soit difficile d’imaginer que l’intervalle allant de 10-38 à 1038 puisse être insuffisant). Par défaut, tous les traitements de Reaktor Core sont effectués en flottants de précision 32-bit. Ceci ne signifie pas forcément que les signaux sont traités comme des flottants en 32-bit, mais que le traitement utilisera au minimum des flottants en 32-bit (bien que des flottants en 64-bit puissent occasionnellement être utilisés comme résultats intermédiaires). Vous pouvez modifier la précision des flottants pour les modules individuels ou pour les macros complètes. Pour les modules individuels, vous effectuez 118 – REAKTOR CORE ce réglage via la propriété FP Precision (“floating point precision”, “précision de la virgule flottante” en anglais) de ces modules: default 32 bit 64 bit utilise la précision par défaut pour la structure en question utilise une précision d’au moins 32 bits utilise une précision d’au moins 64 bits Changer la précision pour un module signifie que, dans ce module, le traitement sera effectué en utilisant la précision spécifiée, et que la valeur de sortie sera aussi générée en utilisant cette précision. Vous pouvez également changer la précision par défaut pour des structures entières si vous faites un clic droit sur le fond et sélectionnez Owner Properties pour ouvrir les propriétés du module en question: La précision par défaut sera effective pour tous les modules à l’intérieur de la structure en question, y compris les macros, tant qu’ils ou elles ne définisREAKTOR CORE – 119 sent pas à leur tour leur propre précision (ou bien, pour les macros, un autre précision par défaut pour les éléments qu’elles contiennent). Les signaux en virgule flottante normaux, d‘une précision de 32 ou 64 bits, sont parfaitement compatibles entre eux et peuvent être librement interconnectés. Les signaux OBC de précisions différentes ne sont pas compatibles entre eux (car vous ne pouvez pas avoir de stockage qui soit à la fois en 32 et en 64 bits). Ainsi, pour les signaux OBC, les réglages “default”, “32 bit” et “64 bit” sont considérés comme étant différents et incompatibles entre eux, car leur précision effective par défaut peut être modifiée en changeant les propriétés de l’une des macros en question. Les modules d’entrée et de sortie des structures du niveau supérieur des cellules core envoient et reçoivent toujours des flottants de 32 bits, car c’est le type de signal utilisé dans les connexions audio et évènements du niveau primaire de Reaktor. 7.2. Les signaux entiers Voici un autre type de données couramment gérées par les processeurs modernes. Ce type de données est en fait plus important encore que les virgules flottantes. Il s’agit des entiers. Les nombres entiers sont représentés et traités avec une précision infinie. Bien que la précision des entiers soit infinie, l’intervalle des valeurs entières représentables est limité. Pour les entiers représentés sur 32 bits, les valeurs peuvent aller jusqu’à plus de 109 (un milliard). La précision infinie des entiers, tant pour le stockage que pour le traitement, est possible uniquement parce qu’ils n’ont aucun chiffre après la virgule. On peut donc les écrire avec un nombre fini de chiffres. Écrivons le nombre de secondes qu’il y a dans une heure: 3, 6, 0, 0, et c’est tout. C’est aussi simple que ça! Encore une fois, si vous essayez d’écrire la valeur de π, vous n’aurez jamais fini: 3, 1, 4, 1, 5... avec les entiers, point de tout cela. Alors que la virgule flottante est une représentation naturelle pour les valeurs changeant continûment (comme les signaux audio), les entiers sont une représentation plus appropriée pour les valeurs changeant de manière discrète (p.ex. les compteurs). 120 – REAKTOR CORE De nombreux modules de Reaktor peuvent être commutés en mode entier, dans lequel ils attendent des valeurs entières en entrée, les traitent comme telles (ie avec une précision infinie) et produisent des valeurs entières en sortie. Comme exemples, on peut citer l’additionneur, le multiplicateur ou le soustracteur. Certains modules ne fonctionnent même qu’en mode entier. Dans Reaktor Core, les valeurs entières ont une longueur minimale de 32 bits garantie. La commutation entre les types entier et flottant (si le module en est capable) est effectuée via la propriété Signal Type du module: Un module réglé sur le mode entier traite les valeurs d’entrée comme des entiers et produit des valeurs entières en sortie. Vous pouvez déterminer si un module est en mode entier grâce à l’apparence différente de ses entrées et sorties: Ce réglage n’existe pas pour les macros, car normalement vous ne construisez pas les structures exactement de la même façon selon que vous leur réservez des entiers ou des flottants (sauf peut-être pour les structures très très simples). Les signaux entiers peuvent être tout à fait connectés à des flottants, mais les câbles reliant des signaux de types différents effectuent automatiquement la conversion, ce qui peut nécessiter une certaine quantité de ressources processeur. À l’heure où nous écrivons ces lignes, cette quantité est décelable sur les PCs REAKTOR CORE – 121 et assez significative sur les Macs. Les connexions OBC de types entier et flottant sont bien sûr incompatibles entre elles. Une telle conversion peut entraîner une perte d‘informations. En particulier, les grands entiers ne peuvent pas être précisément représentés par des flottants, et le contraire est encore plus vrai. Les grands flottants (plus grands que le plus grand entier représentable) ne peuvent pas être représentés par des entiers du tout, auquel cas la conversion est indéfinie. Durant la conversion “flottant vers entier”, les valeurs sont arrondies à l’entier approximativement le plus proche. Le terme “approximativement” signifie, par exemple, que la valeur 0,5 sera arrondie soit à 0, soit à 1, même si vous pouvez être à peu près sûr que la valeur 0,49 sera arrondie à 0 et 0,51 à 1. Il est important de comprendre que la commutation d’un traitement complet en mode entier n’est pas la même chose que la simple conversion de sa sortie en entier. Prenons l’exemple suivant: nous additionnons les deux nombres 2,4 et 4,3 en tant que flottants. Le résultat est 6,7, ce qui, une fois converti en entier, donne 7. La sortie de la structure suivante est donc 8: Si nous passons maintenant le premier additionneur en mode entier, au lieu d’additionner 2,4 et 4,3, nous allons additionner leurs valeurs arrondies, soit respectivement 2 et 4, ce qui donne 6. Le résultat final sera donc 7: Les entrées d’horloge ignorent complètement leurs valeurs entrantes, c’est pourquoi elles sont toujours en virgule flottantes. La conversion du type de signal ne sera donc pas effectuée pour les signaux utilisés uniquement comme horloges: 122 – REAKTOR CORE Ici, l’entrée d’horloge du module Read reste flottante, bien que le module ait été passé en mode entier (les ports OBC ont la même apparence, qu’ils soient en mode entier ou flottant). La réinjection entière est résolue de la même manière que la réinjection flottante – en insérant un module Z^-1 en mode entier (bien sûr, il n’y a plus besoin du système d’élimination des valeurs dénormales). 7.3. Construction d’un compteur d’évènements Construisons un module compteur d’évènements. La fonction de cette macro est similaire à celle de l’accumulateur d’évènements construit plus haut, mais au lieu de sommer les valeurs des évènements, ce module va simplement les compter. Le type entier semble le choix logique pour compter: Tous les modules préfabriqués ainsi que la sortie ont été réglés en mode entier. La macro ILatch est utilisée ici à la place du Latch pour redémarrer le circuit. Les deux macros font exactement la même chose (et se trouvent dans le même menu), mais la première travaille sur les signaux de type entier. Une macro à modulation pour les entiers est aussi utilisée (vous la trouvez dans le menu Expert Macro > Modulation > Integer). Les deux entrées n’ont pas besoin d’être réglées en mode entier, car elles fournissent uniquement des signaux d’horloge. Jetons un œil sur la structure de la cellule core évènement contenant la macro: REAKTOR CORE – 123 Nous voyons que la sortie de ce module n’est pas réglée sur le mode entier (d’ailleurs c’est impossible). Ceci est dû au fait que la cellule core doit, en tant que module du niveau primaire de Reaktor, sortir un évènement normal du niveau primaire, qui est forcément en virgule flottante. Voici une structure de test pour ce compteur: ... et l’allure du panneau correspondant: 7.4. Building a rising edge counter macro Nous allons maintenant discuter de la technique de comparaison de signe, qui pourra vous être utile dans la construction de structures Reaktor Core. La “comparaison de signe” s’attache au signe des nombres (“plus” ou “moins”) sans prêter attention à leur valeur. Bien sûr, “plus” est plus grand que “moins”. Ainsi, par exemple: 3,1 est de signe plus grand que –1,4 2,1 de même signe que 5,0 -4,5 est de même signe que –2,9 Vous pourriez implémenter la comparaison de signe via plusieurs modules de comparaison et plusieurs routeurs, mais il existe une technique plus efficace. Dans Reaktor Core, la comparaison de signe peut être effectuée via le module Compare Sign (Built In Module > Flow > Compare Sign): 124 – REAKTOR CORE Vous pourriez implémenter la comparaison de signe via plusieurs modules de comparaison et plusieurs routeurs, mais il existe une technique plus efficace. Dans Reaktor Core, la comparaison de signe peut être effectuée via le module Compare Sign (Built In Module > Flow > Compare Sign): Le module produit en sortie un signal BootCtl que vous pouvez connecter à un routeur. L’une des utilisations possibles de ce module est la détection de fronts montants dans le signal entrant. Nous entendons par “front montant” une partie croissante du signal. Nous allons construire ci-dessous un compteur de fronts montants sous forme de macro Reaktor Core: Remarquez que la sortie est en mode entier, puisque le décompte est, à n’en pas douter, une valeur entière. La première chose dont nous avons besoin est une macro de détection de front qui convertira le front détecté en évènement: Voici comment la macro de détection peut être implémentée: La chaîne OBC en bas de la structure conserve la valeur précédente du signal d’entrée. Comme nous le voyons, la nouvelle valeur est enregistrée après que REAKTOR CORE – 125 l’ancienne a été lue. Le dernier module Write de la chaîne s’occupe de la tâche d’initialisation pour l’emplacement mémoire de la valeur précédente. Nous initialisons cet emplacement à la valeur –1, afin que la première valeur positive soit comptée comme front montant. Nous avions déjà vu comment utiliser le module Merge pour initialiser l’emplacement mémoire. Le module Write à la fin de la chaîne OBC est une autre technique d’initialisation de la mémoire interne. Il doit être le dernier module Write dans la chaîne, pour pouvoir écraser les résultats déjà enregistrés par les modules Write en amont. Le module Router, contrôlé par le module Sign Comparison, va sélectionner les évènements, ne laissant passer que ceux pour lesquels le signe passe de “négatif” à “positif” (bref les “fronts montants”). Il n’est pas clair qu’un tel module envoie un évènement pendant l’initialisation, en particulier parce que l’emplacement mémoire est encore à zéro lors du traitement des évènements d’initialisation, et le signe de zéro est indéfini. Nous pouvons modifier cette structure de manière à éviter qu‘un événement ne soit envoyé lors de l’initialisation: Le module ES Ctl est un “contrôle sensible aux évènements”. Le signal de contrôle qu’il produit est dans l’état true seulement si un évènement arrive à l’entrée du module. Puisque l’entrée est déconnectée dans la structure cidessus, autrement dit connectée à une constante nulle, la seule fois où le signal de contrôle est égal à true est lors de l’initialisation. Le second routeur va donc bloquer tout évènement survenant pendant l’initialisation et laisser passer tous les autres. Remarquez que nous avons ici un exemple d’un module qui n’envoie pas d’évènement à sa sortie pendant l’initialisation. 126 – REAKTOR CORE Maintenant que nous avons un module détecteur, nous pouvons le connecter à la circuiterie de comptage que nous avons déjà: La fonction de la structure ci-dessus doit être claire. Le module Detect envoie un évènement à chaque fois qu’il détecte un front montant, et ces évènements sont comptés par le module Evt Cnt. Pour construire un circuit de test, plaçons cette macro dans une cellule core audio et comptons les fronts montants d’une forme d’onde en dents de scie. La structure interne de la cellule core ressemble à celle-ci: ... et la structure du niveau primaire à ceci: (n’oubliez pas de régler les propriétés du Meter comme indiqué dans les exemples précédents). Voici ce que vous devriez voir dans le panneau: REAKTOR CORE – 127 La vitesse de changement du nombre doit correspondre à la fréquence de l’oscillateur, définie par le potentiomètre Pitch. Avec un Pitch valant zéro, la fréquence de l’oscillateur est d’environ 8 Hz, donc le nombre devrait être incrémenté environ 8 fois par seconde. 8. Les tableaux 8.1. Introduction aux tableaux Imaginez que vous vouliez construire un module sélecteur de signal audio qui, en fonction de la valeur d’un signal de contrôle en entrée, prenne le signal de l’une des quatre entrées audio: Pour implémenter ce module, une première approche serait d’utiliser des modules Router. Mais il y a une autre possibilité. Nous pouvons utiliser une autre fonctionnalité de Reaktor Core: les tableaux. Un tableau unidimensionnel est une série ordonnée de données du même type qui peuvent être référencées par leur rang dans la collection, ie leur index. Par exemple, prenons un groupe de 5 nombres en virgule flottante: 5.2 16.1 -24.0 11.9 -0.5 Dans Reaktor Core, les indices des éléments d’un tableau démarrent à zéro: le premier élément a pour index 0. Ici, l’élément d’index 0 est 5,2, celui d’index 1 est 16,1, celui d’index 2 est –24,0 et ainsi de suite. Voici une représentation de ce tableau: Index Valuer 0 5.2 128 – REAKTOR CORE 1 16.1 2 -24.0 3 11.9 4 0.5 Dans Reaktor Core, les tableaux sont créés grâce au module Array (ce qui signifie... Tableau en anglais) que l’on trouve dans le sous-menu Built In Module > Memory > Array: Un module Array a une seule sortie, de type Array OBC. La taille du tableau (le nombre d’éléments) et le type de données contenues sont spécifiés dans les propriétés du tableau: Par exemple, pour le tableau ci-dessus, nous devons spécifier le type de données float (virgule flottante) et une taille (size) de 5. Veuillez noter que, comme les indices des tableaux partent de zéro, l’intervalle d’indices pour un tableau de taille 5 serait de 0 à 4 (vous pouvez aussi le voir dans le tableau ci-dessus). Les signaux de type Array OBC correspondant aux différents types de données ne sont pas compatibles entre eux. Pour faire référence à un élément d’un tableau, vous devez spécifier son index. Pour ce faire, vous pouvez utiliser le module Index situé dans Built In Module > Memory > Index: L’entrée OBC maîtresse (en bas) du module Index doit être connectée à la sortie esclave d’un module tableau. Le type de connexion de l’entrée maîtresse doit correspondre au type du tableau, vous devez le spécifier dans les propriétés du module Index: REAKTOR CORE – 129 Et maintenant la connexion: L’entrée supérieure du module Index est toujours de type entier et reçoit la valeur d’index. Ici, nous faisons une référence à l’élément d’index 1 dans le tableau: Notez que le module Const a aussi été réglé sur le mode entier (indiqué par le symbole de sa sortie). Ceci n’est pas nécessaire, puisqu’une conversion automatique est effectuée sinon, mais c’est plus joli. Nous aurions aussi pu utiliser une QuickConst: La sortie du module Index est de type Latch OBC. Ceci signifie que vous pouvez y connecter un module Read ou Write (ou plusieurs d’entre eux). Bien entendu, vous devez veiller à ce que les modules Read et Write soient réglés sur le même type de données que les modules Array et Index. Ici, l’élément d’index 1 du tableau est initialisé à 16,1: 130 – REAKTOR CORE Si un index hors de l’intervalle est envoyé au module Index, le résultat de l’accès au tableau donne une valeur indéfinie. La structure ne plante pas, mais il est impossible de savoir quel élément sera lu, ou même si un élément sera effectivement lu. Ceci signifie que si vous n’êtes pas certain(e) de la taille du tableau, vous devriez la limiter via des modules Router ou des macros de la librairie 8.2. Construction d’un détecteur de signal audio Revenons à la construction de notre module sélecteur de signal audio: Voici une structure interne vide pour construire ce module: Nous allons utiliser un tableau de 4 éléments en virgule flottante pour stocker nos signaux audio: Voici les propriétés du module tableau: REAKTOR CORE – 131 Pour écrire les valeurs d’entrée dans le tableau, nous utilisons une macro standard Write [] disponible dans Expert Macro > Memory > Write []: Cette macro dispose en interne d’un module Index et d’un module Write, effectuant l’écriture dans l’élément du tableau avec l’index spécifié: L’entrée supérieure reçoit bien sûr la valeur à écrire. L’entrée “[]” reçoit l’index auquel l’écriture doit avoir lieu. L’entrée “M” reçoit la connexion OBC à un tableau de flottants à la précision par défaut, et la sortie “S” est une connexion “thru” (ie qui prolonge simplement la chaîne OBC), semblable à celle d’autres modules OBC comme Read et Write. L’entrée “M” et la sortie “S” sont des ports de macro d’un type différent de celui que nous avons utilisé jusqu’à présent. De tels ports peuvent être insérés en sélectionnant l’entrée “Latch” du menu d’insertion de ports (le troisième type de port est le BoolCtl): 132 – REAKTOR CORE Les ports de type “Latch” peuvent servir aux connexions OBC Latch (entre les Reads et les Writes) ou pour les connexions OBC Array. Ces réglages sont à effectuer dans les propriétés du port: Régler le type de connexion sur “Latch” ou “Array” définit le type de connexion OBC. Pour les ports de la macro Write [], ce réglage est visiblement sur “Array”. Le module avec deux lignes horizontales parallèles est le module R/W Order, que l’on trouve dans Built In Module > Memory > R/W Order: Il ne fait rien d’autre que transmettre la connexion de son entrée maîresse (en bas) à sa sortie esclave. L’entrée supérieure n’a absolument aucun effet, si ce n’est celui d’affecter l’ordre de traitement des modules. Tout ce qui est REAKTOR CORE – 133 connecté à la sortie “S” de la macro sera traité après le module Write, ce qui ne serait pas forcément le cas si ce module R/W Order était absent de la structure. En l’absence du module R/W Order, la fonctionnalité de la macro Write [] n’aurait été ni assurée ni intuitive, car l’utilisateur se serait alors attendu à ce que tout ce qui est connecté en aval de la macro Write [] soit traité après elle. En général, de tels problèmes surviennent uniquement avec les connexions OBC; vous devez donc veiller à placer des modules R/W Order aux endroits nécessaires dans les macros que vous concevez. Le module R/W Order, tout comme les ports OBC, dispose d’une propriété Connection Type. Pour ce module, cette propriété ne contrôle que le type des ports “M” et “S”, l’autre entrée étant systématiquement en mode Latch. Pour plus de détails, veuillez vous référer à la description du module R/W Order dans la section de référence. Construisons le circuit permettant d’écrire les signaux d’entrée dans le tableau: 134 – REAKTOR CORE Les quatre modules Write [] se chargent d’enregistrer les valeurs audio entrantes dans le tableau. Nous avons maintenant besoin de lire l’une des quatre valeurs. Nous suggérons d’utiliser la macro Read [] (Expert Macro > Memory > Read []): Cette macro effectue la lecture dans un élément d’un tableau, dont l’index est précisé par l’entrée entière au milieu. L’entrée du haut est l’entrée de l’horloge pour les opérations de lecture – la macro envoie la valeur lue à la sortie du haut, en réponse à un évènement entrant à cette entrée du haut. Les ports en bas sont bien sûr les connexions de tableau maîtresse et esclave. Maintenant, à quoi connectons-nous son entrée maîtresse ? Bien sûr, nous ne pouvons la connecter directement au module tableau, parce que nous voulons que l’opération de lecture soit effectuée après toutes les opérations d’écriture (il pourrait sinon y avoir un délai effectif d’un échantillon, ou pas, bref rien de très fiable). Nous ne pouvons pas non plus la connecter à l’un des modules Write []. Cela ne résoud pas notre problème. Nous suggérons plutôt de connecter les modules Write [] en “ribambelle” derrière le module tableau, autrement dit de les connecter en série, puis de connecter le module Read [] à la sortie du dernier module Write []. Le module Read [] est alors effectivement le dernier. REAKTOR CORE – 135 Maintenant, que connectons-nous à l’entrée index du module Read [] ? Si nous voulons que notre valeur de sélection soit entre 1 et 4, nous devons soustraire 1 à la valeur d’entrée “Sel”. Notez que nous effectuons une soustraction entière (puisque “Sel” est juste une entrée de contrôle, nous n’avons pas vraiment besoin d’une macro à modulation ici): La dernière chose à faire est de cadencer le module de lecture via l’horloge du taux d’échantillonnage (puisqu’il s’agit d’un sélecteur audio): De façon générale, nous aurions dû prendre soin de limiter la valeur d’entrée “Sel” à l’intervalle correct, mais pour nous simplifier la tâche nous n’allons pas le faire maintenant. Voici la structure de test que nous suggérons (nous avons placé la macro dans une cellule core audio): 136 – REAKTOR CORE Le potentiomètre Sel est réglé pour commuter entre les quatre valeurs allant de 1 à 4. Affichez la vue du panneau et observez les différentes formes d’onde en fonction du réglage du potentiomètre: REAKTOR CORE – 137 8.3. Construction d’un délai Maintenant que nous possédons une certaine expérience avec les tableaux, construisons une macro simple de délai audio. Le module doit ressembler à quelque chose comme ça: ... ou encore mieux, à quelque chose comme ça (pour ce faire nous devons régler la propriété Port Alignment de la macro sur “top”): L’entrée “T” reçoit le temps de délai, en secondes. Si vous jetez un œil sur un appareil de délai analogique à bande, vous verrez une boucle de bande combinée à des têtes de lecture et d’enregistrement. Pour être précis, il y a aussi une tête d’effacement, mais pour faire simple nous pouvons imaginer que la tête d’enregistrement effectue à la fois la tâche d’écriture et celle d’effacement. � ������� ��������� Si nous voulons simuler cet appareil sous forme numérique, il nous faut une sorte de boucle de bande digitale. De par la nature discrète du monde numérique, la boucle de “bande digitale” contiendra un nombre fini d’échantillons audio. Ces échantillons seront enregistrés et lus au taux d’échantillonnage audio: 138 – REAKTOR CORE � ������� ��������� Un choix naturel pour cette “boucle de bande digitale” est un tableau dont la taille est égale au nombre d’échantillons enregistrés dans la boucle. Dans un délai analogique à bande, le temps de délai dépend de la distance entre les têtes de lecture et d’enregistrement - qui est fixe - et de la vitesse de défilement de la bande - qui est variable - et ce pour des raisons techniques évidentes: il est bien plus facile de faire varier la vitesse de la bande que l’écartement des têtes... Dans le monde digital, il se trouve que c’est le contraire: faire varier la vitesse de la bande revient à effectuer une conversion du taux d’échantillonnage entre la “bande digitale” et la sortie, alors que faire varier la distance entre les têtes est relativement simple. C’est donc ce que nous allons faire de ce pas: � ������� ��������� Il y a une autre différence notable avec le monde analogique. Dans le monde analogique, la bande se déplace. Si nous voulions déplacer notre “bande digitale”, nous serions obligés de copier tous les éléments du tableau dans l’élément voisin pour chaque battement de l’horloge audio, ce qui coûterait cher en ressources processeur. À la place, nous allons plutôt déplacer les têtes. De tout ceci, nous pouvons conclure que nous avons besoin des éléments suivants: REAKTOR CORE – 139 Tableau Index d’écriture Index de lecture – notre simulation de “boucle de bande digitale” – notre tête d’enregistrement – notre tête de lecture Les index de lecture et d’enregistrement se déplacent donc à travers le tableau, échantillon par échantillon. Au moment où l’un d’eux atteint la fin du tableau, il doit être renvoyé au début du tableau (ce qui correspond à scotcher la fin de la bande avec son début). La différence entre la position de lecture et celle d’écriture correspond au temps de délai mesuré en échantillons. Cette technique est en fait assez classique en programmation, on l’appelle la technique du “tampon circulaire” (“circular buffer”), ou “tampon en anneau” (“ring buffer”). Commençons par programmer la “tête d’enregistrement”. Cette fonction est très similaire à l’oscillateur en dents de scie que nous avons déjà programmé, si ce n’est que les calculs sont effectués en mode entier. Le pas d’incrémentation vaut 1 (pour chaque tic-tac audio), l’intervalle des valeurs de sortie va de 0 à N-1, où N est la taille du tableau. Plaçons cette circuiterie dans une macro “RecordPos”: L’entrée “N” doit recevoir le nombre d’éléments du tableau, et la sortie “Pos” doit générer la position courante d’enregistrement (l’index). Voici comment implémenter cette macro (comparez avec l’implémentation de l’oscillateur en dents de scie vu plus haut): Notez que le module de comparaison est réglé sur “>=”. Le signe “=” était sans importance pour l’oscillateur en dents de scie, mais pour les calculs sur les entiers, la différence se révèle généralement décisive. La condition “>=” garantit que la tête d’enregistrement n’atteindra jamais la valeur N. Au niveau supérieur, nous créons un module tableau et le connectons à ce RecordPos via le module Size [] (disponible dans Built In Module > Memory > Size []), qui renvoie la taille du tableau: 140 – REAKTOR CORE La taille du tableau peut aller jusqu’à 44100 emplacements. Ceci nous autorise jusqu’à 1 seconde de délai (une seconde moins un échantillon, pour être précis) au taux d’échantillonnage de 44,1 kHz: Il nous faut maintenant calculer les véritables index. Pour ce faire, nous allons construire deux macros. La première macro va convertir le temps de délai demandé en distance, exprimée en échantillons: Ceci peut être effectué en multipliant le temps (en secondes) par le taux d’échantillonnage (en Hertz). Nous devons aussi penser à limiter le résultat, la macro Expert Macro > Clipping >IClipMinMax devrait faire l’affaire: REAKTOR CORE – 141 Nous nous limitons à N-1 car c’est effectivement la plus grande distance possible entre deux éléments du tableau. Notez que la conversion en entiers est effectuée après la multiplication. Nous aurions aussi pu limiter directement la valeur d’entrée (à une valeur différente, bien sûr), ce qui est généralement plus approprié, puisque les valeurs flottantes au-delà des limites de représentation des entiers peuvent produire des valeurs entières arbitraires, rendant alors la limitation sans objet. Nous utilisons ensuite une autre macro pour calculer l’index de lecture à partir de RecordPos et Distance: La position de lecture doit être située à Distance échantillons derrière la position d’enregistrement, c’est pourquoi nous effectuons leur soustraction: La valeur de la distance passe par un loquet car elle est produite par une entrée de contrôle qui peut potentiellement recevoir des évènements à n’importe quel moment, et nous ne voulons pas que la soustraction survienne à d’autres moments que les évènements de l’horloge audio. Si nous nous contentons de soustraire, la différence risque d’être souvent négative. Ceci est dû au fait que notre tableau n’est pas une boucle, ses extrémités ne sont pas connectées entre elles. Nous devons donc cycliser le résultat: -1 doit devenir N-1, -2 doit devenir N-2, -3 doit devenir N-3, etc. 142 – REAKTOR CORE Plaçons donc une autre macro pour la cyclisation: Comme RecordPos et Distance sont tous deux entre 0 et N-1, nous savons que leur différence ne peut pas être inférieure à que –N+1. La cyclisation peut donc être réalisée par une simple addition de N: Revenons à notre structure du niveau supérieur. Nous avons maintenant les indices de lecture et d’enregistrement, il nous reste à effectuer ces mêmes lectures et enregistrements: Notez que la lecture se a lieu après l’écriture et qu’elle est cadencée par l’horloge du taux d’échantillonnage. Voici la structure de test que nous proposons. N’oubliez pas de placer un convertisseur ms2sec dans la cellule core Delay, ni de régler celle-ci en mode monophonique: REAKTOR CORE – 143 En fait, il est conseillé de passer le délai en mode monophonique dès que possible, car pour chaque voix il consomme environ 200 Ko de mémoire. En effet, 44100 échantillons, utilisant 4 octets (32 bits) chacun, font en tout: 44100*4 = 176400 octets = un peu plus de 172 Ko (un kilooctet contient 1024 octet) Pour tester la structure ci-dessus, jouez des notes sur votre clavier MIDI et écoutez-les retardées de la durée spécifiée par le potentiomètre Time. 8.4. Les tables Il existe un autre module similaire à Array. Il s’appelle Table et se trouve dans le sous-menu Built In Module > Memory > Table: Les tables sont en fait des tableaux un peu particulier, en ceci que vous ne pouvez que lire dans les tables, l’écriture y étant interdite. Les valeurs d’une table sont préinitialisées via les propriétés du module. Pour accéder à la liste des valeurs, appuyez sur le bouton dans la fenêtre de propriétés: Cliquez ici pour modifier les valeurs Une nouvelle boîte de dialogue doit apparaître: 144 – REAKTOR CORE Vous voyez une table vide. Elle contient un seul élément, de valeur zéro. Vous pouvez maintenant commencer à saisir les nouvelles valeurs manuellement ou les importer depuis un fichier. Si vous choisissez l’option manuelle, cliquez sur le bouton . La boîte de dialogue suivante apparaît: Vous devez sélectionner le type de valeurs stockées dans la table, sa taille (le nombre d’éléments qu’elle contient) et une valeur pour initialiser tous les éléments de la table. Vous pouvez également importer la table depuis un fichier. Le fichier peut être aux formats WAV/AIFF, texte (TXT/ASC) ou Native Table (NTF). Pour importer depuis un fichier, appuyez sur le bouton Une boîte de dialogue apparaît et vous permet de sélectionner un fichier. Puis une autre boîte de dialogue vous demande de sélectionner le type de données pour les valeurs de la table. REAKTOR CORE – 145 Essayons d’utiliser une table. Nous allons construire une macro d’oscillateur sinusoïdal via l’approche “lecture de table”: Dans cette macro, commençons par créer un module table: Nous l’initialisons via le fichier sinetable.txt que nous vous avons préparé dans le dossier “Core Turorial Examples”, dans le dossier d’installation de Reaktor. Il s’agit d’un fichier texte contenant les valeurs d’une fonction sinus, sur une période entière plus un sample. Importez-les en tant que valeurs flottantes Float32: Vous pouvez aussi visualiser les valeurs chargées sous l’aspect d’une forme d’onde. Les boutons et commutent entre les deux affichages “liste” et “forme d’onde”. Appuyez sur OK pour fermer la boîte de dialogue et transférer les valeurs à la table. Il existe également une propriété FP Precision, que vous trouverez dans la fenêtre de propriétés de la table. Elle ne contrôle pas vraiment la précision 146 – REAKTOR CORE des valeurs dans la table (celle-ci aurait dû être sélectionnée lors de l’importation des valeurs depuis un fichier ou lors de leur saisie manuelle). Elle définit plutôt la précision “formelle” de la sortie du module Table. De façon générale, laissez cette propriété sur “Default”: Précision formelle de la sortie Maintenant que nous avons la table, continuons à construire l’oscillateur. Il sera basé sur un “oscillateur de phase” qui génèrera un signal en dents de scie montantes, de 0 jusqu’à la taille de la table moins un: L’implémentation de l’oscillateur de phase est assez semblable à celle d’un oscillateur en dents de scie ou à celle de la position d’enregistrement dans le délai précédent: Un module Read [], connecté à l’oscillateur de phase et cadencé par l’horloge du taux d’échantillonnage, accède à l’élément correspondant dans la table et extrait sa valeur. REAKTOR CORE – 147 La structure de test que nous suggérons est la suivante (n’oubliez pas le convertisseur P2F dans la cellule core): ... dont voici le panneau: Bien entendu, le sinus produit ne sonne pas très bien car nous n’avons pas effectué d’interpolation. Nous vous laissons le plaisir de construire une version avec interpolation si vous le souhaitez. 148 – REAKTOR CORE 9. Construction de structures optimisées La règle dit: aucun outil n’est parfait. La technologie Reaktor Core ne fait pas exception. Cela ne signifie pas qu’elle soit mauvaise, bien au contraire, nous pensons que cette technologie est tout simplement géniale . Pas parfait signifie réel. Cela implique que vous deviez avoir quelques connaissances sur comment tirer le meilleur parti de cette technologie. Appelez cela “Trucs et astuces” ou quoi que ce soit d’autre. Nous allons ici discuter de ces questions d’optimisation. 9.1. Les Latches et les macros à modulation Utilisez les Latches (loquets) et/ou les macros à modulation à tous les endroits nécessaires, pour être sûr(e) de retarder les évènements jusqu’à ce qu’ils doivent effectivement être traités. Voici une structure qui utilise une macro à modulation pour la multiplication dans la boucle d’itération audio. L’utilisation de la macro à modulation évite que le traitement soit lancé par les évènements de l’entrée “a”: Nous pourrions tout aussi bien utiliser un loquet explicite dans la structure: Nous avons déjà mentionné de nombreux exemples de cette technique plus haut dans ce manuel. L’utilisation des loquets intéresse à la fois l’optimisation des performances et l’exactitude de vos structures. Certaines erreurs typiques de la programmation de structures sont liées à l’envoi d’évènements à certains modules aux mauvais moments. REAKTOR CORE – 149 Ne craignez pas que les loquets diminuent les performances de vos structures. Les loquets ne consomment pas beaucoup, voire pas du tout de ressources processeur. Les loquets sont généralement préférés aux routeurs pour le filtrage des évènements, car ils consomment moins de puissance processeur. Autant que faire se peut, utilisez les routeurs uniquement lorsque la logique du traitement impose leur emploi. 9.2. Routage et mélange Le routage peut être plus ou moins coûteux en termes de puissance de calcul, selon la situation et votre plateforme. Si vous pouvez éviter le routage sans ajouter d’opérations coûteuses à votre structure, faites-le ! Le routage ES Ctl peut être parfois remplacé par des Latches. Si possible, ayez recours à ce remplacement. Si vous séparez le chemin d’évènements en deux branches via un routeur, il est souhaitable de mélanger ces branches après leur traitement différentiel: Il est aussi conseillé de mélanger au routeur les évènements entrants (non séparés): Le mélange ne doit pas forcément être effectué via un module Merge. N’importe quel module arithmétique ou similaire fait l’affaire: 150 – REAKTOR CORE Le mélange peut aussi se faire dans une macro (en fonction de sa structure interne): Il peut être nécessaire ou raisonnable de mélanger les branches générées par différents routeurs, mais veillez alors à la consommation de puissance processeur. 9.3. Les opérations numériques Pour les nombres en virgule flottante, l’addition, la soustraction, la valeur absolue et l’opposé sont généralement les opérations les plus économiques. Pour les entiers, ce sont l’addition, la soustraction et l’opposé. La valeur absolue d’un entier est aussi relativement économique. L’élimination des valeurs dénormales du module DN Cancel est, comme vous vous en rappelez, une simple addition. En revanche, la division de flottants, la multiplication et la division d’entiers consomment en moyenne plus de puissance. Il est conseillé de regrouper vos opérations d’une manière telle que les plus coûteuses soient effectuées le plus rarement possible. Par exemple, si vous devez calculer une fréquence normalisée en divisant la fréquence en Hertz par le taux d’échantillonnage, il est judicieux de calculer d’abord l’inverse du taux d’échantillonnage puis de multiplier le résultat par la fréquence: REAKTOR CORE – 151 Dans la structure ci-dessus, la division est effectuée seulement lors des changements de taux d’échantillonnage, qui devraient être plutôt rares. Les changements de la fréquence ne relancent que la multiplication. Comparez avec l’implémentation directe de la même formule: dans laquelle la division est effectuée en réponse à chaque changement de la fréquence. 9.4. Conversions entre flottants et entiers De manière générale, évitez toute conversion inutile entre flottants et entiers. Selon la plateforme, ces conversions peuvent utiliser une part non négligeable de la puissance processeur. Les conversions nécessaires doivent être maintenues, bien sûr... Bien que la structure suivante fonctionne comme prévu, elle comprend en fait deux conversions inutiles entre entiers et flottants: La première conversion a lieu à l’entrée du module additionneur, au milieu. Ce module est réglé pour travailler avec des flottants, mais il reçoit un signal entier en entrée. Il convertit donc les entiers en flottants. La seconde conversion a lieu à l’entrée du module de valeur absolue, qui est réglé en mode entier alors qu’il reçoit les flottants issus de la sortie de l’additionneur. Il convertit donc les flottants en entiers. 152 – REAKTOR CORE Voici une bien meilleure façon de procéder: Tous les modules sont réglés en mode entier, il n’y donc aucune conversion à faire. Les signaux d’horloge doivent généralement être de type flottant, mais si un signal entier est utilisé, ce n’est pas un problème: Même si l’entrée d’horloge du Latch est flottante, elle est cadencée par un signal entier. Comme la valeur de l’horloge est sans importance, aucune conversion n’est effectuée. REAKTOR CORE – 153 Annexe A. Interface utilisateur de Reaktor Core A.1. Les cellules core Une cellule core peut être créée dans la structure du niveau primaire de Reaktor (sauf dans la structure de l’ensemble) via un clic droit sur le fond et en sélectionnant Core Cell > New Audio ou Core Cell > New Event. Les cellules core des librairies (utilisateur comme système) se trouvent dans le même menu “Core Cell”. Vous pouvez également charger les cellules core via la commande Core Cell > Load…. Pour supprimer une cellule core, sélectionnez-la et appuyez sur la touche Suppr, ou bien faites un clic droit sur la cellule core et sélectionnez la commande Delete. Il est aussi possible de supprimer une sélection multiple. Pour enregistrer une cellule core dans un fichier, faites un clic droit sur la cellule core et sélectionnez la commande Save Core Cell As…. Pour modifier la structure interne de la cellule core, double-cliquez dessus. Pour resortir de sa structure, double-cliquez sur le fond. Pour modifier les propriétés externes de la cellule core, faites un clic droit sur la cellule et sélectionnez Properties. Si la fenêtre de propriétés est déjà ouverte, il vous suffit de cliquer sur la cellule. Pour modifier ses propriétés internes, vous devez vous rendre dans sa structure interne, faire un clic droit sur le fond de l’écran et sélectionner Owner Properties. Si la fenêtre de propriétés est déjà ouverte, il vous suffit de cliquer sur le fond. A.2. Les macros et modules core Pour créer un module ou une macro core normal(e), faites un clic droit dans la partie centrale (la plus grande) de la structure core et sélectionnez l’un(e) des modules/macros dans les menus Built In Module, Expert Macro, Standard Macro, ou User Macro. Vous pouvez aussi charger un(e) module/macro par un clic droit sur le fond et en sélectionnant la commande Load Module…. Une macro vide peut être créée depuis le menu Built In Module. 154 – REAKTOR CORE Pour enregistrer un(e) module/macro core dans un fichier, faites un clic droit dessus et sélectionnez la commande Save As…. Pour supprimer un(e) module/macro core, sélectionnez-le(la) et appuyez sur la touche Suppr, ou bien faites un clic droit dessus et sélectionnez la commande Delete. Il est aussi possible de supprimer une sélection multiple. Pour modifier la structure interne du module / de la macro core, double-cliquez dessus. Pour resortir de sa structure, double-cliquez sur le fond. Pour modifier les propriétés du module / de la macro core, vous devez vous rendre dans sa structure interne, faire un clic droit sur le fond de l’écran et sélectionner Owner Properties. Si la fenêtre de propriétés est déjà ouverte, il vous suffit de cliquer sur le fond. Vous pouvez également accéder aux propriétés du module / de la macro core depuis l’extérieur, via un clic droit dessus et en sélectionnant Properties. Si la fenêtre de propriétés est déjà ouverte, il vous suffit de cliquer sur le module / la macro. A.3. Les ports core Pour créer un port core, effectuez un clic droit dans la zone de gauche (entrées) ou de droite (sorties) de la structure core et sélectionnez l’un des types de ports disponibles dans le sous-menu New. Pour supprimer un port core, sélectionnez-le et appuyez sur la touche Suppr, ou bien faites un clic droit dessus et sélectionnez la commande Delete. Il est aussi possible de supprimer une sélection multiple (y compris une sélection mixte de modules/ports). A.4. Modification de la structure core Pour déplacez un module core, cliquez dessus et déplacez-le vers l’endroit souhaité. Les ports peuvent être déplacé uniquement verticalement, leur ordre vertical définissant leur ordre d’apparition à l’extérieur. Pour créer une connexion entre une entrée d’un module et une sortie d’un autre, cliquez sur l’un des ports et déplacez le curseur sur l’autre port. Pour supprimer une connexion, cliquez sur le câble de connexion pour le sélectionner, puis appuyez sur la touche Suppr. Vous pouvez aussi cliquer sur REAKTOR CORE – 155 l’entrée et déplacer le curseur n’importe où sur le fond de l’écran. Pour créer une QuickConst, effectuez un clic droit sur l’entrée d’un module et sélectionnez Connect to New QuickConst. Pour accéder aux propriétés de la QuickConst, cliquez simplement sur celle-ci. Pour créer un QuickBus, effectuez un clic droit sur une entrée ou une sortie d’un module et sélectionnez Connect to New QuickBus. Pour connecter une entrée ou une sortie de module à un QuickBus existant, cliquez sur cette entrée ou cette sortie, et sélectionnez l’un des bus disponibles dans le menu Connect to QuickBus. Annexe B. Le concept de Reaktor Core B.1. Les signaux et les évènements Les signaux peuvent être de type flottant ou entier. Les ports flottants ressemblent à ceci: , et les ports entiers à cela: Les signaux se propagent sous la forme d’évènements à travers les connexions depuis les sorties jusqu’aux entrées connectées. Un évènement est une action basique qui se produit à une sortie particulière, changeant la valeur de cette sortie (dans certains cas, la valeur est changée en elle-même). Tous les évènements provenant de la même source d’évènements sont considérés comme “simultanés”. Ceci signifie que si deux évènements arrivent à différentes entrées d’un même module, ils arrivent “simultanément”. “La même source” signifie la même sortie: dans certaines circonstance, plusieurs sorties peuvent être considérées comme “une même source d’évènements”. Par exemple, toutes les entrées audio et connexions d’horloge du taux d’échantillonnage standard sont considérées comme une même source d’évènements. Dans ce contexte, “la même source” ne signifie pas forcément “la même valeur” mais plutôt leur “simultanéité”. À moins qu’un module donné soit une source d’évènements, la seule chose pouvant commander le traitement de ses valeurs entrantes est un ou plusieurs évènements arrivant à ses entrées. S’il s’agit d’évènements multiples, un seul évènement est produit en sortie, puisque les évènements en entrée arrivent simultanément. 156 – REAKTOR CORE B.2. L’initialisation L’initialisation des structures s’effectue de la façon suivante. D’abord, toutes les valeurs sont remises à zéro. Puis l’évènement d’initialisation est envoyé simultanément depuis toutes les sources d’initialisation. Généralement, il s’agit des constantes, des entrées des cellules core (mais pas toujours) et des horloges. C’est tout. B.3. Les connexions OBC Les OBC (Object Bus Connections) sont des connexions entre modules qui n’envoient aucun signal mais déclarent juste que les modules partagent un même état commun (mémoire). La connexion de ce type la plus courante est celle entre des modules Read et Write accédant à une même valeur enregistrée. B.4. Le routage Vous pouvez utiliser les modules Router pour diriger le flux d’évènements entre deux chemins possibles. Si le Router choisit l’un des chemins de sortie pour les évènements entrants, l’autre sortie ne reçoit pas d’évènement (cela signifie en particulier que la valeur de cette autre sortie ne peut pas être modifiée). Le Router est contrôlé par une connexion d’entrée de type BoolCtl. À l’autre extrémité de cette connexion, vous avez généralement un module Compare (parfois, d’autres modules intermédiaires comme des ports de macro BoolCtl peuvent se trouver entre le Compare et le Router). En utilisant les Routers, vous pouvez dynamiquement activer ou désactiver les calculs dans certaines parties de vos structures. En général, après avoir séparé le chemin du signal en deux via un Router, vous voudrez remélanger les deux branches via un module Merge ou un autre module. Souvent, vous voudrez mélanger une des branches au signal original non séparé. De manière générale, vous êtes libre de faire ici ce qu’il vous plaira (mais faites tout de même attention à la consommation de ressources processeur). B.5. Le “latching” Le “latching” (utilisation des Latches, ou loquets) est probablement la technique la plus courante dans Reaktor Core. Elle consiste à utiliser des modules Latch pour éviter que des évènements ne soient envoyés aux mauvais instants. REAKTOR CORE – 157 Par exemple, vous ne voudriez pas qu’un évènement de signal de contrôle ne lance un calcul dans une boucle audio. Vous pouvez aussi utiliser les macros du groupe Expert Macros > Modulation, qui est un ensemble des combinaisons de Latches les plus courantes, avec quelques modules de traitement arithmétique. B.6. Les horloges Les horloges sont des sources d‘évènements. D‘habitude, les évènements d‘horloge arrivent à des intervalles réguliers qui correspondent à la fréquence de l‘horloge. Vous avez besoin d‘horloges pour piloter différents modules comme les oscillateurs, les filtres, etc. La plupart des implémentations de ces modules n‘ont pas besoin d’une connexion d‘horloge explicite venant de l‘extérieur: ils utilisent implicitement une source d‘horloge standard disponible dans les structures core. Cette source est l‘horloge du taux d‘échantillonnage, qui tourne à la fréquence audio par défaut. Veuillez noter que, dans les cellules core évènements, bien que la connexion à l‘horloge du taux d‘échantillonnage soit disponible, le signal d‘horloge lui-même n‘est pas disponible. C‘est pourquoi la plupart des oscillateurs, filtres et autres modules similaires ne fonctionnent pas dans les cellules core évènements. Annexe C. Les ports des macros core C.1. In Reçoit un évènement entrant depuis l’extérieur et le transfère inchangé à sa propre sortie interne. La connexion d’entrée interne peut être utilisée pour forcer la signification par défaut (déconnectée) de ce port. C.2. Out Reçoit un évènement arrivant à l’entrée interne et le transfère inchangé à l’extérieur 158 – REAKTOR CORE C.3. Latch (entrée) Transfère une connexion OBC de l’extérieur de la macro à l’intérieur de la macro. La connexion d’entrée interne peut être utilisée pour forcer la signification par défaut (déconnectée) de ce port. C.4. Latch (sortie) Transfère une connexion OBC de l’intérieur de la macro à l’extérieur de la macro C.5. Bool C (entrée) Transfère une connexion BoolCtl de l’extérieur de la macro à l’intérieur de la macro. La connexion d’entrée interne peut être utilisée pour forcer la signification par défaut (déconnectée) de ce port. C.6. Bool C (sortie) Transfère une connexion BoolCtl de l’intérieur de la macro à l’extérieur de la macro. REAKTOR CORE – 159 Annexe D. Les ports des cellules core D.1. In (mode audio) Donne accès au signal audio venant de l’extérieur du module. Envoie des évènements réguliers à la cadence du taux d’échantillonnage (synchronisés à SR.C, l’horloge globale du taux d’échantillonnage). ÉVÈNEMENT D’INITIALISATION: envoie un évènement d’initialisation. Sa valeur est définie par l’initialisation extérieure. D.2. Out (mode audio) Donne accès depuis l’extérieur du module aux valeurs reçues à l’intérieur. À tout instant, la dernière valeur reçue est transférée à l’extérieur. D.3. In (mode évènement) Convertit les évènements du niveau primaire de Reaktor venant de l’extérieur en évènements Reaktor Core et les transfère à l’intérieur. ÉVÈNEMENT D’INITIALISATION: envoie un évènement d’initialisation si un évènement d’initalisation est reçu de l’extérieur. D.4. Out (mode évènement) Convertit les évènements Reaktor Core venant de l’intérieur en évènements du niveau primaire de Reaktor et les transfère à l’extérieur. Si plusieurs sorties en mode évènements reçoivent simultanément des évènements Reaktor Core, les évènements correspondant du niveau primaire sont envoyés dans l’ordre des sorties supérieures vers les sorties inférieures. 160 – REAKTOR CORE Annexe E. Les bus intégrés E.1. SR.C Envoie des évènements d’horloge réguliers à la cadence du taux d’échantillonnage. ÉVÈNEMENT D’INITIALISATION: envoie toujours un évènement d’initialisation. E.2. SR.R Fournit le taux d’échantilonnage courant, en Hertz. Envoie des évènements avec les nouvelles valeurs en réponse aux changements du taux d’échantillonnage. ÉVÈNEMENT D’INITIALISATION: envoie toujours un évènement d’initialisation avec le taux d’échantillonnage initial. Annexe F. Les modules d’usine F.1. Const Génère un signal de valeur constante. Cette valeur est affichée dans le module. ÉVÈNEMENT D’INITIALISATION: PROPRIÉTÉS: Value durant l’initialisation, envoie l’évènement avec la valeur spécifiée. C‘est le seul instant où ce module envoie un événement. la valeur à envoyer en sortie REAKTOR CORE – 161 F.2. Math > + Génère en sortie la somme des signaux en entrée. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.3. Math > - Génère en sortie la différence des signaux en entrée (le signal à l’entrée inférieure est soustrait au signal à l’entrée supérieure). L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.4. Math > * Génère en sortie le produit des signaux en entrée. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.5. Math > / Génère le quotient des signaux en entrée (le signal à l’entrée supérieure est divisé par le signal à l’entrée inférieure). En mode entier, produit une division avec reste, le reste étant abandonné. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). 162 – REAKTOR CORE F.6. Math > |x| Génère en sortie la valeur absolue du signal entrant. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. F.7. Math > –x Génère en sortie la valeur opposée (inversion du signe) du signal entrant. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. F.8. Math > DN Cancel Modifie le signal entrant de manière à supprimer les nombres dénormaux. L’implémentation actuelle ajoute une toute petite constante. Fonctionne uniquement avec les nombres en virgule flottante. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. F.9. Math > ~log Calcule une approximation du logarithme de la valeur entrante. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. PROPRIÉTÉS: Base Precision base du logarithme précision de l’approximation (une meilleure précision demande plus de puissance processeur) REAKTOR CORE – 163 F.10. Math > ~exp Calcule une approximation de l’exponentielle de la valeur entrante. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. PROPRIÉTÉS: Base Precision base de l’exponentielle précision de l’approximation (une meilleure précision demande plus de puissance processeur) F.11. Bit > Bit AND Effectue la fonction binaire ET sur les signaux entrants. Fonctionne uniquement sur les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.12. Bit > Bit OR Effectue la fonction binaire OU sur les signaux entrants. Fonctionne uniquement sur les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.13. Bit > Bit XOR Effectue la fonction binaire OU EXCLUSIF sur les signaux entrants. Fonctionne uniquement sur les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). 164 – REAKTOR CORE F.14. Bit > Bit NOT Effectue l’inversion binaire du signal entrant. Fonctionne uniquement sur les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive en entrée. F.15. Bit > Bit << Décale vers la gauche les bits de la valeur à l’entrée supérieure (vers les bits plus significatifs). La quantité du décalage est spécifiée par l’entrée inférieure. Le résultat pour N < 0 et N > 31 est indéfini (donc utilisez cette fonction seulement pour 0 ≤ N ≤ 31). Fonctionne uniquement sur les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.16. Bit > Bit >> Décale vers la droite les bits de la valeur à l’entrée supérieure (vers les bits moins significatifs). Aucune extension de signe n’est effectuée. La quantité du décalage est spécifiée par l’entrée inférieure. Le résultat pour N < 0 et N > 31 est indéfini (donc utilisez cette fonction seulement pour 0 ≤ N ≤ 31). Fonctionne uniquement avec les entiers. L’évènement de sortie est envoyé à chaque fois qu’un évènement arrive à l’une des entrées (ou aux deux simultanément). F.17. Flow > Router Assigne le signal de l’entrée signal (entrée inférieure) à l’une des deux sorties en fonction de l’état du signal de contrôle (entrée supérieure). Si le signal de contrôle est dans l’état true, le module assigne le signal à la sortie 1 (supérieure), et à la sortie 0 (inférieure) si le signal de contrôle est dans l’état REAKTOR CORE – 165 false. L’évènement de sortie est envoyé à l’une des sorties à chaque fois qu’un évènement arrive à l’entrée signal. F.18. Flow > Compare Produit un signal BoolCtl en sortie, indiquant le résultat de la comparaison des valeurs d’entrée. La valeur à l’entrée supérieure est placée à gauche du signe de comparaison et la valeur à l’entrée inférieure à droite du signe (p.ex. le module montré ci-dessus vérifie si la valeur du haut est plus grande que celle du bas). PROPRIÉTÉS: Criterion l’opération de comparaison à effectuer. F.19. Flow > Compare Sign Produit un signal BoolCtl en sortie, indiquant le résultat de la comparaison du signe des valeurs d’entrée. La valeur à l’entrée supérieure est placée à gauche du signe de comparaison et la valeur à l’entrée inférieure à droite du signe (p.ex. le module montré ci-dessus vérifie si le signe de la valeur du haut est plus grand que le signe de la valeur du bas). La comparaison de signe est définie comme suit: + est égal à + – est égal à – + est plus grand que – Le signe d’une valeur nulle est indéfini, donc une valeur arbitraire peut être générée si l’une des valeurs comparées est nulle. PROPRIÉTÉS: Criterion l’opération de comparaison à effectuer. 166 – REAKTOR CORE F.20. Flow > ES Ctl Produit en sortie un signal BoolCtl indiquant la présence momentanée d’un évènement en entrée (le signal vaut true s’il y a un évènement à l’entrée de ce module à cet instant précis). F.21. Flow > ~BoolCtl Produit en sortie un signal BoolCtl qui est l’inversion du signal BoolCtl d’entrée (true se change en false et réciproquement). F.22. Flow > Merge Envoie un évènement en sortie à chaque fois qu’il y a un évènement à l’une des entrées, ou à plusieurs simultanément. Si une seule entrée reçoit un évènement à un instant donné, la valeur de l’évènement en sortie est égale à la valeur de cet évènement en entrée. Si plusieurs entrées reçoivent des évènements simultanément, la valeur de l’entrée la plus basse (parmi celles recevant un évènement à cet instant) est transmise. Par exemple, si la deuxième et la troisième entrée (en partant du haut) reçoivent un évènement, la valeur de l’évènement à la troisième entrée sera transmise. PROPRIÉTÉS: Input Count nombre d’entrées du module F.23. Flow > EvtMerge La fonction de ce module est similaire à celle du module Merge, si ce n’est qu’ici les valeurs des entrées sont ignorées. La valeur de la sortie est indéfinie. Ce module est conçu pour générer des signaux d’horloge. Il fonctionne REAKTOR CORE – 167 uniquement en mode virgule flottante, puisque de toute façon la valeur n’est pas censée servir à quoi que ce soit. PROPRIÉTÉS: Input Count nombre d’entrées du module F.24. Memory > Read Lit la valeur stockée dans la mémoire de la chaîne OBC à laquelle ce module appartient. La lecture se produit en réponse à un évènement à l’entrée supérieure (horloge) et la valeur lue est envoyée à la sortie supérieure. Les ports du bas sont les connexions OBC maîtresse (à gauche) et esclave (à droite). F.25. Memory > Write Écrit la valeur arrivant à l’entrée supérieure dans la mémoire de la chaîne OBC à laquelle ce module appartient. L’écriture se produit en réponse à un évènement à l’entrée supérieure. Les ports du bas sont les connexions OBC maîtresse (à gauche) et esclave (à droite). F.26. Memory > R/W Order Ce module n’effectue aucune action. Il peut être inséré dans une structure pour contrôler l’ordre de traitement des modules connectés par OBC. Les ports OBC du bas sont les connexions OBC maîtresse et esclave, connectées en interne en “thru” (transmission simple). L’entrée OBC supérieure est la connexion “secondaire”, qui permet de placer ce module logiquement après le module connecté à cette entrée. L’entrée secondaire ne peut être connectée qu’à des signaux de type OBC Latch normaux. Les ports maître et esclave peuvent quant à eux être connectés à des signaux de type OBC Latch ou Array (loquet ou tableau), selon les réglages des propriétés du module R/W Order. En tout cas, le type de signal et la 168 – REAKTOR CORE précision doivent être les mêmes pour toutes les connexions de ce module (p.ex. vous ne pouvez pas connecter en même temps l’entrée secondaire à un Read en mode entier et les connexions maîtresse et esclave à des modules en mode flottants). PROPRIÉTÉS: Connection Type type de connexion du port “thru” (loquet ou tableau). F.27. Memory > Array Définit un objet mémoire de type tableau. Le module lui-même n’effectue aucune action. Toutes les opérations sur le tableau doivent être effectuées par des modules connectés à la sortie du tableau, qui est une connexion OBC esclave de type tableau. PROPRIÉTÉS: Size nombre d’éléments dans le tableau. F.28. Memory > Size [ ] Renvoie la taille de l’objet tableau connecté à l’entrée. La taille est une valeur entière constante. ÉVÈNEMENT D’INITIALISATION: pendant l’initialisation, envoie en sortie un évènement ayant pour valeur la taille du tableau. C‘est le seul moment où ce module envoie un événement. F.29. Memory > Index Donne accès à un élément du tableau. L’accès est donné sous la forme d’une connexion OBC Latch associée à l’élément du tableau. L’association est établie et/ou modifiée en envoyant un évènement à l’entrée supérieure (index) REAKTOR CORE – 169 du module Index, qui démarre à zéro et est toujours en mode entier. L’entrée inférieure est la connexion OBC maîtresse vers le tableau. La sortie fournit la connexion OBC Latch à l’élément tableau, sélectionné par l’entrée d’index. Le type de valeur et la précision sont bien sûr les mêmes pour les connexions OBC d’entrée et de sortie, ils sont contrôlés par les propriétés du module. F.30. Memory > Table Définit un tableau préinitialisé en lecture seule. Le module lui-même n’effectue aucune action. Toutes les opérations sur la table doivent être effectuées par des modules connectés à la sortie de la table, qui est une connexion OBC esclave de type tableau. PROPRIÉTÉS: FP Precision modifie les valeurs dans la table. contrôle la précision formelle de la connexion de sortie. F.31. Macro Fournit un conteneur pour une structure interne. Le nombre d’entrées et de sorties n’est pas fixé, il est défini par la structure interne. PROPRIÉTÉS: FP Precision contrôle la précision formelle de la connexion de sortie. Look commute entre les apparences Large (label et noms des ports visibles) et Small (label et noms des ports invisibles). Pin Alignment contrôle l’alignement des ports dans la vue externe de la macro Solid contrôle le traitement de la macro par le moteur de Reaktor Core. Si cette option est désactivée, les limites de la macro sont transparentes, notamment pour la résolution des réinjections. Laissez cette option ACTIVÉE, à moins que vous ne sachiez ex-ac-te-ment ce que vous faites ! Icon le bouton charge une nouvelle icône pour la macro, et le bouton efface l’icône (aucune icône assignée). 170 – REAKTOR CORE Annexe G. Les macros expertes G.1. Clipping > Clip Max / IClip Max Le signal à l’entrée supérieure est borné supérieurement par la valeur de seuil à l’entrée du bas. Les changements de seuil ne génèrent pas d’évènement. G.2. Clipping > Clip Min / IClip Min Le signal à l’entrée supérieure est borné inférieurement par la valeur de seuil à l’entrée du bas. Les changements de seuil ne génèrent pas d’évènement. G.3. Clipping > Clip MinMax / IClipMinMax Le signal à l’entrée supérieure est borné inférieurement par la valeur de seuil à l’entrée du milieu, et supérieurement par la valeur de seuil à l’entrée du bas. Les changements de seuil ne génèrent pas d’évènement. G.4. Math > 1 div x Calcule l’inverse de la valeur d’entrée. G.5. Math > 1 wrap Boucle les valeurs entrantes dans l’intervalle [-0,5.. 0,5] (la période de bouclage vaut 1). REAKTOR CORE – 171 G.6. Math > Imod Calcule le reste de la division de la valeur supérieure par la valeur inférieure. L’évènement de sortie est envoyé à chaque fois qu’il y a un évènement à l’une des deux entrées (ou aux deux simultanément). G.7. Math > Max / IMax Calcule le maximum des valeurs d’entrée. L’évènement de sortie est envoyé à chaque fois qu’il y a un évènement à l’une des deux entrées (ou aux deux simultanément). G.8. Math > Min / IMin Calcule le minimum des valeurs d’entrée. L’évènement de sortie est envoyé à chaque fois qu’il y a un évènement à l’une des deux entrées (ou aux deux simultanément). G.9. Math > round Arrondit la valeur entrante à l’entier le plus proche. L’arrondi des valeurs exactement au milieu entre deux entiers n’est pas défini. Par exemple, 1,5 sera arrondi à 1 ou à 2. G.10. Math > sign +Génère en sortie soit 1, soit –1, en fonction du signe de l’entrée (les nombres positifs génèrent 1, les négatifs –1, et zéro ne génère pas de sortie). 172 – REAKTOR CORE G.11. Math > sqrt (>0) Approximation de la racine carrée. Fonctionne uniquement pour les entrées positives. G.12. Math > sqrt Approximation de la racine carrée. G.13. Math > x(>0)^y Approximation de x^y (“x puissance y”). x doit être positif. L’évènement de sortie est envoyé à chaque fois qu’il y a un évènement à l’une des deux entrées (ou aux deux simultanément). G.14. Math > x^2 / x^3 / x^4 Calcule x à la puissance 2/3/4. G.15. Math > Chain Add / Chain Mult Additionne/multiplie les signaux entre eux, du bas vers le haut. L’évènement de sortie est généré s’il y a un ou plusieurs évènements à une ou plusieurs entrées. G.16. Math > Trig-Hyp > 2 pi wrap Boucle les valeurs entrantes sur l’intervalle [-π..π] (la période de bouclage est 2π). REAKTOR CORE – 173 G.17. Math > Trig-Hyp > arcsin / arccos / arctan Approximation de l’arcsinus/arccosinus/arctangente. G.18. Math > Trig-Hyp > sin / cos / tan Approximation du sinus/du cosinus/de la tangente. G.19. Math > Trig-Hyp > sin –pi..pi / cos –pi..pi / tan –pi..pi Approximation du sinus/du cosinus/de la tangente (fonctionne seulement sur l’intervalle [-π..π]). G.20. Math > Trig-Hyp > tan –pi4..pi4 Approximation de la tangente (fonctionne seulement sur l’intervalle [-π /4..π /4]). G.21. Math > Trig-Hyp > sinh / cosh / tanh Approximation du sinus/du cosinus/de la tangente hyperboliques. G.22. Memory > Latch / ILatch “Bloque” (retarde) le signal à l’entrée supérieure jusqu’à ce qu’un évènement d’horloge arrive à l’entrée inférieure. Si deux évènements arrivent simultanément aux deux entrées, le signal entrant passe directement en sortie. 174 – REAKTOR CORE G.23. Memory > z^-1 / z^-1 ndc Envoie en sortie la dernière valeur reçue à l’entrée supérieure, en réponse à l’évènement d’horloge de l’entrée inférieure. Si l’entrée d’horloge est déconnectée, le module utilise l’horloge audio standard (SR.C) à la place, fonctionnant alors de fait comme un délai d’un échantillon. Les deux modules peuvent automatiquement résoudre les boucles de réinjection, la version Z^-1 assurant de plus l’élimination des valeurs dénormales. La version Z^-1 ndc ne doit être utilisée que lorsque les valeurs dénormales ne sont pas attendues en entrée. G.24. Memory > Read [] Lit une valeur dans un tableau à un index donné (spécifié par l’entrée du milieu), en réponse à un évènement d’horloge entrant (entrée supérieure). L’entrée inférieure (OBC) est la connexion au tableau. Utilisez la sortie OBC pour créer des chaînes OBC et “sérialiser” les opérations d’accès au tableau ! G.25. Memory > Write [] Écrit une valeur (reçue à l’entrée supérieure) dans un tableau, à un index donné (spécifié par l’entrée du milieu). L’opération d’écriture est commandée par toute valeur entrante. L’entrée inférieure (OBC) est la connexion au tableau. Utilisez la sortie OBC pour créer des chaînes OBC et “sérialiser” les opérations d’accès au tableau ! REAKTOR CORE – 175 G.26. Modulation > x + a / Integer > Ix + a Ajoute un paramètre (entrée inférieure) au signal (entrée supérieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. G.27. Modulation > x * a / Integer > Ix * a Multiplie le signal (entrée supérieure) par un paramètre (entrée inférieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. G.28. Modulation > x – a / Integer > Ix – a Soustrait un paramètre (entrée inférieure) au signal (entrée supérieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. G.29. Modulation > a – x / Integer > Ia – x Soustrait le signal (entrée supérieure) à un paramètre (entrée inférieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. G.30. Modulation > x / a Divise le signal (entrée supérieure) par un paramètre (entrée inférieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. 176 – REAKTOR CORE G.31. Modulation > a / x Divise un paramètre (entrée inférieure) par le signal (entrée supérieure) en réponse à un signal entrant. Les changements du paramètre ne génèrent pas d’évènements. G.32. Modulation > xa + y Multiplie le signal à l’entrée supérieure par un paramètre de gain (entrée du milieu) et ajoute le résultat au signal de l’entrée inférieure. Les évènements à l’une des deux entrées signal (ou aux deux) génèrent une nouvelle valeur, contrairement aux évènements arrivant à l’entrée paramètre. Annexe H. Les macros standard H.1. Audio Mix-Amp > Amount Fournit un contrôle linéaire et inversible sur l’amplitude d’un signal audio. A=0 coupe le signal A=1 laisse le signal intact A = -1 inverse le signal Usage typique: contrôler la quantité de réinjection audio. H.2. Audio Mix-Amp > Amp Mod REAKTOR CORE – 177 Module l’amplitude du signal audio par une certaine quantité (AM) sur une échelle linéaire AM = 1 double l’amplitude AM = 0 pas de changement AM = -1 coupe le signal Usage typique: trémolo, modulation d’amplitude. H.3. Audio Mix-Amp > Audio Mix Mixe deux signaux ensemble. H.4. Audio Mix-Amp > Audio Relay Commute entre les deux signaux audio d’entrée. Si ‘x’ est plus grand que 0, le module prend le signal 1, sinon il prend le signal 0. H.5. Audio Mix-Amp > Chain (amount) Pondère l’amplitude du signal audio par une certaine quantité (A) et mélange le résultat avec le signal audio enchaîné (>>). A=0 le signal est coupé (mis en sourdine) A=1 le signal reste inchangé A = -1 le signal est inversé Usage typique: chaînes de mixage audio, contrôle de la quantité de réinjection audio. 178 – REAKTOR CORE H.6. Audio Mix-Amp > Chain (dB) Pondère l’amplitude du signal audio par une certaine quantité de décibels (dB) et mélange le résultat avec le signal audio enchaîné (>>). Usage typique: chaînes de mixage audio. H.7. Audio Mix-Amp > Gain (dB) Pondère l’amplitude du signal audio par une certaine quantité de décibels (dB). +6 dB double l’amplitude 0 dB pas de changement -6 dB diminue l’amplitude de moitié Usage typique: contrôle du volume du signal, en échelle de dB. H.8. Audio Mix-Amp > Invert Inverse la polarité du signal audio. H.9. Audio Mix-Amp > Mixer 2 … 4 Mixe les signaux audio entrants (In1, In2, …) en atténuant leurs niveaux d’une certaine quantité de dB (Lvl1, Lvl2, …). REAKTOR CORE – 179 H.10. Audio Mix-Amp > Pan Règle la balance du signal audio en utilisant une courbe parabolique. Pos = -1 tout à gauche Pos = 0 centre Pos = 1 tout à droite H.11. Audio Mix-Amp > Ring-Amp Mod Le signal audio porteur (entrée du haut) est modulé par le signal audio de l’entrée “Mod”. Le type de modulation est contrôlé par l’entrée “R/A”, qui effectue un fondu entre la modulation en anneau et la modulation d’amplitude. R/A = 0 modulation en anneau R/A = 1 modulation d’amplitude (pour une vraie modulation d’amplitude, l’amplitude du modulateur de doit pas dépasser 1) H.12. Audio Mix-Amp > Stereo Amp Amplifie un signal audio monophonique d’une certaine quantité de décibels et le place dans le champ panoramique à la position spécifiée. La position panoramique est définie comme suit: -1 tout à gauche 0 centre 1 tout à droite 180 – REAKTOR CORE H.13. Audio Mix-Amp > Stereo Mixer 2 … 4 Mixe les signaux audio entrants (In1, In2, …) en atténuant leurs niveaux d’une certaine quantité de dB (Lvl1, Lvl2, …) et en les plaçant dans le champ stéréo aux positions spécifiées (Pan1, Pan2, …). Les positions panoramiques sont définies comme suit: -1 tout à gauche 0 centre 1 tout à droite H.14. Audio Mix-Amp > VCA Amplificateur audio avec contrôle linéaire de l’amplitude. A=0 coupe le signal (sourdine) A=1 laisse le signal inchangé Usage typique: connecter une enveloppe d’amplitude à l’entrée A. Remarque: pour une amplification négative, utilisez le module Audio Amount. H.15. Audio Mix-Amp > XFade (lin) Crossfader (mélangeur) audio avec courbe linéaire. x=0 seul le signal 0 est entendu x = 0,5 mélange égal des deux signaux x=1 seul le signal 1 est entendu Remarque: le crossfader parabolique donne généralement de meilleurs résultats sonores. REAKTOR CORE – 181 H.16. Audio Mix-Amp > XFade (par) Crossfader (mélangeur) audio avec courbe parabolique. Donne généralement de meilleurs résultats sonores que le crossfader linéaire. x=0 seul le signal 0 est entendu x = 0,5 mélange égal des deux signaux x=1 seul le signal 1 est entendu H.17. Audio Shaper > 1+2+3 Shaper Fournit un modelage contrôlable du signal audio du 2ème et du 3ème ordre. L’entrée “1st” spécifie la quantité de signal original (1=inchangé, 0=absent). Les entrées “2nd” et “3rd” correspondent respectivement aux quantités de distorsion du deuxième et du troisième ordre. H.18. Audio Shaper > 3-1-2 Shaper Modeleur du signal audio avec quantité variable de distorsion du 2ème ou du 3ème ordre. La quantité de distorsion et son type sont contrôlés par l’entrée “Shp”: Shp = 0 pas de modelage Shp > 0 modelage du 3ème ordre Shp < 0 modelage du 2ème ordre 182 – REAKTOR CORE H.19. Audio Shaper > Broken Par Sat Saturation parabolique brisée. Segment linéaire autour du niveau zéro. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). L’entrée “H” règle la dureté (entre 0 et 1). Les valeurs plus élevées correspondent à un segment linéaire plus important au milieu. L’entrée “S” contrôle la symétrie de la courbe de saturation (de –1 à 1). À 0, la courbe est symétrique. H.20. Audio Shaper > Hyperbol Sat Saturation hyperbolique simple. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). Cependant, la “saturation totale” n’est jamais atteinte avec ce type de saturation. H.21. Audio Shaper > Parabol Sat Saturation parabolique simple. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). Remarque: la saturation totale est atteinte avec un niveau d’entrée égal à 2L. REAKTOR CORE – 183 H.22. Audio Shaper > Sine Shaper 4 / 8 Modeleur en sinus du 4ème / 8ème ordre. Le modeleur du 8ème ordre effectue une meilleure approximation du sinus, mais il consomme plus de puissance processeur. H.23. Control > Ctl Amount Fournit un contrôle linéaire (éventuellement négatif) sur l’amplitude d’un signal de contrôle. A=0 coupe le signal A=1 laisse le signal intact A = -1 inverse le signal Usage typique: contrôler la quantité de modulation. H.24. Control > Ctl Amp Mod Module l’amplitude du signal de contrôle par une certaine quantité (AM) sur une échelle linéaire. AM = 1 double l’amplitude AM = 0 pas de changement AM = -1 coupe le signal H.25. Control > Ctl Bi2Uni Convertit un signal bipolaire de –1 à 1 en signal unipolaire. L’entrée “a” contrôle la quantité de conversion: à 0 il n’y a aucun changement, à 1 (valeur 184 – REAKTOR CORE par défaut) la conversion est totale. Usage typique: connecter immédiatement après un LFO pour ajuster la polarité de la modulation. H.26. Control > Ctl Chain Pondère l’amplitude du signal audio par une certaine quantité (A) et mélange le résultat avec le signal audio enchaîné (>>). A=0 le signal est coupé (mis en sourdine) A=1 le signal reste inchangé A = -1 le signal est inversé Usage typique: chaînes de mixage audio. H.27. Control > Ctl Invert Inverse la polarité du signal de contrôle. H.28. Control > Ctl Mix Mixe deux signaux de contrôle. H.29. Control > Ctl Mixer 2 Mixe deux signaux de contrôle (In1 et In2) avec les facteurs de gain spécifiés (A1 et A2). A=0 pas de signal A=1 signal inchangé A = -1 signal inversé REAKTOR CORE – 185 H.30. Control > Ctl Pan Règle la balance du signal de contrôle en utilisant une courbe parabolique Pos = -1 tout à gauche Pos = 0 centre Pos = 1 tout à droite H.31. Control > Ctl Relay Commute entre deux signaux de contrôle. Si ‘x’ est plus grand que 0, le module transmet le signal 1, sinon il transmet le signal 0. H.32. Control > Ctl XFade Crossfader (mélangeur) pour signaux de contrôle avec courbe linéaire. x=0 seul le signal 0 est trnasmis x = 0,5 mélange égal des deux signaux x=1 seul le signal 1 est transmis H.33. Control > Par Ctl Shaper Applique une double courbe parabolique au signal de contrôle. Le signal d’entrée doit être dans l’intervalle [–1..1]. Le signal de sortie est aussi dans [–1..1]. La quantité de torsion est contrôlée par l’entrée “b” (dont l’intervalle est encore une fois [–1..1]). b=0 pas de torsion (courbe linéaire) b = -1 torsion maximale “vers” l’axe des X b=1 torsion maximale “vers” l’axe des Y 186 – REAKTOR CORE Vous pouvez aussi utiliser ce modeleur pour les signaux dans l’intervalle [0..1], auquel cas seule une moitié de la courbe est utilisée. Usage typique: vélocité et autres modelages de contrôleurs. H.34. Convert > dB2AF Convertit un signal de contrôle de l’échelle de décibels à l’échelle linéaire de gain d’amplitude. 0 dB 1.0 -6 dB 0.5 etc. H.35. Convert > dP2FF Convertit un signal de contrôle de l’échelle de pitch (hauteur tonale, en demitons) à l’échelle des ratios de fréquences. 12 demi-tons 2 -12 demi-tons -2 etc. H.36. Convert > logT2sec Convertit le temps logarithmique du niveau primaire de Reaktor (utilisé pour les enveloppes) en secondes. 0 0.001 sec 60 1 sec etc. H.37. Convert > ms2Hz Convertit une période temporelle en millisecondes dans la fréquence correspondante en Hertz. P.ex. 100 ms 10 Hz. REAKTOR CORE – 187 H.38. Convert > ms2sec Convertit le temps en millisecondes en un temps en secondes. P.ex. 500ms 0.5 sec. H.39. Convert > P2F Convertit un signal de contrôle de l’échelle de pitch (hauteur tonale) à l’échelle de fréquences. P.ex. pitch 69 440 Hz. H.40. Convert > sec2Hz Convertit une période temporelle en secondes dans la fréquence correspondante en Hertz. P.ex. 0.1sec 10 Hz. H.41. Delay > 2 / 4 Tap Delay 4p Délai à 2/4 battements avec 4 points d’interpolation. Les entrées T1 à T4 spécifient la durée de délai (en secondes) pour chacun des battements. La durée maximale de délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. H.42. Delay > Delay 1p / 2p / 4p Délai 1-point (non interpolé) / 2-points / 4-points. L’entrée T spécifie la durée du délai en secondes. La durée maximale de délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. 188 – REAKTOR CORE Utilisez les versions interpolées du délai pour réaliser des délais modulés. Pour les délais non modulés (durée fixe de délai), la version non interpolée donne habituellement de meilleurs résultats. H.43. Delay > Diff Delay 1p / 2p / 4p Délai à diffusion 1-point (non interpolé) / 2-points / 4-points. L’entrée T spécifie la durée du délai en secondes. Les entrées Dffs règlent les facteurs de diffusion. La durée maximale de délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. H.44. Envelope > ADSR Génère une enveloppe ADSR. A, D, R stemps d’attaque, de décroissance (ou chute) et de relâchement (ou extinction) en secondes. S niveau de maintien (intervalle entre 0 et 1, à 1 le niveau de maintien est égal au niveau maximal). G entrée gate. Les évènements positifs entrants (re)démarrent l’enveloppe. Les évènements nuls ou négatifs arrêtent l’enveloppe. GS sensibilité du gate. Pour une sensibilité nulle, le maximum de l’enveloppe a toujours une amplitude de 1. Pour une sensibilité égale à 1, le maximum de l’enveloppe est égal au niveau du gate positif. RM mode de redéclenchement. Commute entre les modes analogique et digital d’une part, et entre les modes redémarrage et legato REAKTOR CORE – 189 RM RM RM RM = = = = 0 1 2 3 d’autre part. En mode “digital”, l’enveloppe redémarre toujours de zéro alors qu’en mode “analogique” elle redémarre de son niveau de sortie actuel. En mode “redémarrage”, les évènements gate positifs redémarrent l’enveloppe, alors qu’en mode legato celle-ci redémarre seulement quand les gates passent d’une valeur négative/nulle à une valeur positive. Voici les valeurs de RM autorisées: redémarrage analogique (par défaut) legato analogique redémarrage digital legato digital H.45. Envelope > Env Follower Produit en sortie un signal de contrôle qui “suit” l’enveloppe du signal audio entrant. Les entrées A et D spécifient les temps d’attaque et de décroissance du suivi, en secondes. H.46. Envelope > Peak Detector Produit en sortie le “dernier” pic du signal audio entrant, sous forme de signal de contrôle. L’entrée D spécifie le temps de décroissance du niveau de sortie, en secondes. H.47. EQ > 6dB LP/HP EQ Égaliseur passe-bas (LP) / passe-haut (HP) à 1 pôle (6 dB/octave). L’entrée F spécifie la fréquence de coupure (en Hz) pour les deux sorties LP et HP. 190 – REAKTOR CORE H.48. EQ > 6dB LowShelf EQ Égaliseur à étage bas à 1 pôle. L’entrée dB spécifie l’accentuation des basses fréquences, en dB (les valeurs négatives atténuent ces fréquences). L’entrée F spécifie la fréquence de transition, en Hertz. H.49. EQ > 6dB HighShelf EQ Égaliseur à étage haut à 1 pôle. L’entrée dB spécifie l’accentuation des hautes fréquences, en dB (les valeurs négatives atténuent ces fréquences). L’entrée F spécifie la fréquence de transition, en Hertz. H.50. EQ > Peak EQ Égaliseur à pic/creux à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, l’entrée BW spécifie la largeur de bande (en anglais bandwidth) en octaves, et l’entrée dB spécifie la hauteur du pic (les valeurs négatives produisant un creux). H.51. EQ > Static Filter > 1-pole static HP Filtre passe-haut statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz. REAKTOR CORE – 191 H.52. EQ > Static Filter > 1-pole static HS Filtre à étage haut statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée B l’accentuation des hautes fréquences en dB. H.53. EQ > Static Filter > 1-pole static LP Filtre passe-bas statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz. H.54. EQ > Static Filter > 1-pole static LS Filtre à étage bas statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée B l’accentuation des basses fréquences en dB. H.55. EQ > Static Filter > 2-pole static AP Filtre passe-tout statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). H.56. EQ > Static Filter > 2-pole static BP 192 – REAKTOR CORE Filtre passe-bande statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, et l’entrée Res la résonance (entre 0 et 1). H.57. EQ > Static Filter > 2-pole static BP1 Filtre passe-bande statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, et l’entrée Res la résonance (entre 0 et 1). L’amplification à la fréquence centrale est toujours égale à 1, quelle que soit la résonance. H.58. EQ > Static Filter > 2-pole static HP Filtre passe-haut statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). H.59. EQ > Static Filter > 2-pole static HS Filtre à étage haut statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res spécifie la résonance (entre 0 et 1) et l’entrée B l’accentuation des hautes fréquences en dB. H.60. EQ > Static Filter > 2-pole static LP Filtre passe-bas statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). REAKTOR CORE – 193 H.61. EQ > Static Filter > 2-pole static LS Filtre à étage bas statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res spécifie la résonance (entre 0 et 1) et l’entrée B l’accentuation des hautes fréquences en dB. H.62. EQ > Static Filter > 2-pole static N Filtre en creux statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). H.63. EQ > Static Filter > 2-pole static Pk Filtre en pic statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, l’entrée Res la résonance (entre 0 et 1) et l’entrée B l’accentuation à la fréquence centrale en dB. H.64. EQ > Static Filter > Integrator Intègre le signal audio entrant (calcule sa primitive) via la méthode des sommes rectangulaires. Un évènement à l’entrée Rst réinitialise la sortie de l’intégrateur à la valeur de cet évènement. 194 – REAKTOR CORE H.65. Event Processing > Accumulator Calcule la somme des valeurs arrivant à l’entrée supérieure. Un évènement à l’entrée Set réinitialise la sortie à la valeur de cet évènement. La valeur de la sortie inférieure est la somme de tous les évènements précédents, la valeur de la sortie supérieure est la somme de tous les évènements précédents sauf le dernier. H.66. Event Processing > Clk Div Diviseur de fréquence d’horloge. Les évènements d’horloge arrivant à l’entrée supérieure sont filtrés, le module ne laissant passer que le 1er, le N+1ème, le 2N+1ème, etc. (N est la valeur à l’entrée inférieure, elle spécifie le ratio de la division). H.67. Event Processing > Clk Gen Génère des évènements d’horloge à la fréquence spécifiée par l’entrée (en Hz). Ce module fonctionne uniquement à l’intérieur des cellules core audio. H.68. Event Processing > Clk Rate Estime la fréquence et la période des évènements du signal d’horloge entrant. La sortie F est la fréquence en Hz, et la sortie T la période en secondes. Ce module fonctionne uniquement à l’intérieur des cellules core audio. La valeur initiale de la période est zéro, et la fréquence est une valeur très grande. Vous obtenez une estimation raisonnable en sortie seulement après le deuxième évènement d’horloge en entrée. REAKTOR CORE – 195 H.69. Event Processing > Counter Compte le nombre d’évènements arrivant à l’entrée supérieure. Un évènement à l’entrée Set réinitialise la sortie à la valeur de cet évènement. La valeur de la sortie inférieure est le décompte de tous les évènements précédents, et la valeur de la sortie supérieure est le décompte de tous les évènements précédents sauf le dernier. H.70. Event Processing > Ctl2Gate Convertit le signal de contrôle (ou audio) de l’entrée supérieure en signal gate (signal en porte) avec pour amplitude la valeur à l’entrée inférieure A. Les passages du signal à zéro dans le sens croissant ouvrent la porte, les passages à zéro dans le sens décroissant ferment la porte. H.71. Event Processing > Dup Flt / IDup Flt Filtre les évènements en double (seuls les évènements avec une valeur différente de l’évènement précédent sont transmis). H.72. Event Processing > Impulse Génère une impulsion d’un échantillon, d’amplitude 1, en réponse à un évènement entrant. Ce module fonctionne uniquement dans les cellules core audio. 196 – REAKTOR CORE H.73. Event Processing > Random Génère des nombres aléatoires en réponse aux horloges entrantes. L’intervalle de sortie est [–1..1]. Un évènement à l’entrée Seed (“Graine” en anglais) relance le générateur avec la valeur de cet évènement. H.74. Event Processing > Separator / ISeparator Les évènements à l’entrée supérieure ayant une valeur supérieure à la valeur de l’entrée Thld (pour “Threshold”, “Seuil” en anglais) sont envoyés à la sortie Hi. Les autres sont envoyés à la sortie Lo. H.75. Event Processing > Thld Crossing Dès qu’un signal croissant, à l’entrée supérieure, dépasse le seuil fixé par l’entrée inférieure, un évènement est envoyé à la sortie supérieure. H.76. Event Processing > Value / IValue Change la valeur de l’évènement arrivant à l’entrée supérieure et lui attribue la valeur de l’évènement disponible à cet instant à l’entrée inférieure. H.77. LFO > MultiWave LFO REAKTOR CORE – 197 Génère simultanément en sortie plusieurs oscillateurs basse fréquence (LFOs) calés en phase, avec différentes formes d’onde. L’entrée F spécifie la fréquence en Hz, l’entrée W la largeur du train d’impulsions (dans l’intervalle de –1 à 1, valable uniquement pour la sortie “train d’impulsions”), les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.78. LFO > Par LFO Génère un signal de contrôle basse fréquence parabolique. L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.79. LFO > Random LFO Génère un signal de contrôle basse fréquence aléatoire (méthode “random sample-and-hold”, littéralement “échantillon-et-maintien aléatoire”). L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.80. LFO > Rect LFO Génère un signal de contrôle basse fréquence rectangulaire (ou train d’impulsions). L’entrée F spécifie la fréquence en Hz, l’entrée W contrôle la largeur des impulsions (dans l’intervalle de –1 à 1), et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). 198 – REAKTOR CORE H.81. LFO > Saw(down) LFO Génère un signal de contrôle basse fréquence en dents de scie descendantes. L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.82. LFO > Saw(up) LFO Génère un signal de contrôle basse fréquence en dents de scie montantes. L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.83. LFO > Sine LFO Génère un signal de contrôle basse fréquence sinusoïdal. L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). H.84. LFO > Tri LFO Génère un signal de contrôle basse fréquence triangulaire. L’entrée F spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). REAKTOR CORE – 199 H.85. Logic > AND Effectue la conjonction (opération logique ET) de deux signaux: la sortie vaut 1 si et seulement si les deux entrées valent 1. Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini. H.86. Logic > Flip Flop La sortie est commutée entre 0 et 1 à chaque fois que l’entrée d’horloge reçoit un évènement. H.87. Logic > Gate2L Convertit un signal de gate en signal logique. La “porte ouverte” produit la valeur 1 en sortie, la “porte fermée” produit la valeur 0. H.88. Logic > GT / IGT Compare les deux valeurs flottantes/entières entrantes puis génère 1 si la valeur du haut est plus grande que celle du bas, et 0 dans le cas contraire. H.89. Logic > EQ Compare les deux valeurs entières entrantes et génère 1 si elles sont égales, et 0 dans le cas contraire. H.90. Logic > GE 200 – REAKTOR CORE Compare les deux valeurs entières entrantes et génère 1 si la valeur du haut est plus grande que (ou égale à) celle du bas, et 0 dans le cas contraire. H.91. Logic > L2Clock Convertit un signal logique en signal d’horloge. Le passage du signal d’entrée de 0 à 1 envoie l’évènement d’horloge. Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini.. H.92. Logic > L2Gate Convertit un signal logique en signal gate. Le passage du signal d’entrée de 0 à 1 ouvre la porte, le passage de l’entrée de 1 à 0 la ferme. Le niveau du signal gate “porte ouverte” est défini par la valeur à l’entrée inférieure (par défaut = 1). Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini. H.93. Logic > NOT Convertit les 0 en 1 et vice versa. Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini. H.94. Logic > OR Effectue la disjonction (opération logique OU) de deux signaux logiques: la sortie vaut 1 si au moins une des deux entrées vaut 1. Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini. H.95. Logic > XOR Effectue une disjonction exclusive (opération logique OU EXCLUSIF) de deux REAKTOR CORE – 201 signaux logiques: la sortie vaut 1 si une seule des entrées vaut 1 (et l’autre 0). Pour les valeurs d’entrées autres que 0 et 1, le résultat est indéfini. H.96. Logic > Schmitt Trigger Passe la sortie à 1 si l’entrée devient supérieure à L+ (par défaut 0,67), et à 0 si l’entrée devient inférieure à L- (par défaut 0,33). H.97. Oscillators > 4-Wave Mst Génère quatre formes d’onde audio calées en phase. La fréquence est spécifiée par l’entrée F (en Hz). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée ‘pw’, dans l’intervalle de –1 à 1. Cet oscillateur peut fonctionner avec des fréquences négatives et dispose de plus d’une sortie de synchronisation pour l’oscillateur esclave équivalent, 4-Wave Slv. H.98. Oscillators > 4-Wave Slv Génère quatre formes d’onde audio calées en phase. La fréquence est spécifiée par l’entrée F (en Hz). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée ‘pw’, dans l’intervalle de –1 à 1. Cet oscillateur peut fonctionner avec des fréquences négatives. Il peut aussi être synchronisé à un autre oscillateur 4-Wave Mst/Slv via l’entrée Snc. L’entrée SncH contrôle la dureté de la synchronisation (0 = pas de synchro, de 0 à 1 202 – REAKTOR CORE = degré croissant de synchronisation souple). Une sortie de synchronisation pour un autre oscillateur 4-Wave Slv est également disponible. H.99. Oscillators > Binary Noise Générateur de bruit blanc binaire. Produit aléatoirement les valeurs –1 ou 1. Un évènement entrant à l’entrée Seed (ré)initialise le générateur aléatoire interne avec une valeur “graine” donnée (la valeur de l’évènement). H.100. Oscillators > Digital Noise Générateur de bruit blanc numérique. Produit des valeurs aléatoires dans l’intervalle [-1..1]. Un évènement entrant à l’entrée Seed (ré)initialise le générateur aléatoire interne avec une valeur “graine” donnée (la valeur de l’évènement H.101. Oscillators > FM Op Opérateur classique de FM (Modulation de Fréquence). Produit une onde sinusoïdale dont la fréquence est définie par l’entrée F (en Hz). Le sinus peut être modulé en phase par l’entrée PhM (en radians). Un évènement arrivant à l’entrée Rst redémarre l’oscillateur à la phase spécifiée par la valeur de cet évènement (intervalle de 0 à 1). H.102. Oscillators > Formant Osc Génère une forme d’onde avec une fréquence fondamentale spécifiée par l’entrée F (en Hz) et une fréquence de formant spécifiée par l’entrée Fmt (en Hz aussi). REAKTOR CORE – 203 H.103. Oscillators > MultiWave Osc Génère quatre formes d’onde audio calées en phase. La fréquence est spécifiée par l’entrée F (en Hz). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée ‘pw’, dans l’intervalle de –1 à 1. Cet oscillateur ne peut pas fonctionner avec des fréquences négatives. H.104. Oscillators > Par Osc Génère une forme d’onde audio parabolique. L’entrée F spécifie la fréquence en Hz. H.105. Oscillators > Quad Osc Génère une paire de formes d’onde sinusoïdales calées en phase, avec un décalage de phase de 90°. L’entrée F spécifie la fréquence en Hertz. H.106. Oscillators > Sin Osc Génère une onde sinusoïdale. L’entrée F spécifie la fréquence en Hz. H.107. Oscillators > Sub Osc 4 204 – REAKTOR CORE Génère quatre sous-harmoniques calées en phase. La fréquence “fondamentale” est spécifiée par l’entrée F (en Hz). Les nombres sous-harmoniques sont spécifiés par les entrées S1 à S4 (intervalle 1..120). L’entrée Tbr contrôle le contenu harmonique de la forme d’onde de sortie (intervalle 0..1). H.108. VCF > 2 Pole SV Filtre 2-pôles à variable d’état. L’entrée F spécifie la fréquence de coupure en Hz et l’entrée Res la résonance (intervalle 0..0,98). Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. H.109. VCF > 2 Pole SV C Filtre 2-pôles à variable d’état (version compensée). Offre un meilleur comportement aux fréquences de coupures élevées. L’entrée F spécifie la fréquence de coupure en Hz et l’entrée Res la résonance (intervalle 0..0,98). Vous pouvez également utiliser des valeurs négatives de résonance, elles augmentent encore plus la pente. Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. H.110. VCF > 2 Pole SV (x3) S Filtre 2-pôles à variable d’état avec un suréchantillonnage optionnel (version x3) et une saturation. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res la résonance (intervalle 0..1) et l’entrée Sat le niveau de saturation REAKTOR CORE – 205 (intervalle typique: de 8 à 32). Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. H.111. VCF > 2 Pole SV T (S) Filtre 2-pôles à variable d’état avec compensation et saturation optionnelle (version S). Offre un meilleur comportement aux fréquences de coupures élevées, quoique légèrement différent de celui de la version 2 Pole SV C. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res la résonance (intervalle 0..1) et l’entrée Sat le niveau de saturation (intervalle typique: de 8 à 32).Les sorties HP/BP/LP produisent respectivement les signaux passehaut, passe-bande et passe-bas. H.112. VCF > Diode Ladder Émulation linéaire d’un filtre à échelle de diodes. L’entrée F spécifie la fréquence de coupure (en Hz) et Res spécifie la résonance (intervalle de 0 à 0,98). H.113. VCF > D/T Ladder Émulation linéaire de filtre à échelle, fondu possible entre les comportements “diode” et “transistor”. L’entrée F spécifie la fréquence de coupure (en Hz), l’entrée Res spécifie la résonance (intervalle de 0 à 0,98) et l’entrée D/T con- 206 – REAKTOR CORE trôle la balance entre les diodes et les transistors (0=diode, 1=transistor). H.114. VCF > Ladder x3 Une émulation d’un filtre à échelle de transistor saturant (suréchantillonné trois fois). L’entrée F spécifie la fréquence de coupure (en Hz), l’entrée Res spécifie la résonance (intervalle de 0 à 1) et l’entrée SatL spécifie le niveau de saturation (intervalle typique entre 1 et 32). Les sorties 1 à 4 sont prises aux étages correspondants de l’échelle émulée. Prenez l’étage 4 pour le son de filtre à échelle “classique”. REAKTOR CORE – 207 Annexe I. Core cell library I.1. Audio Shaper > 3-1-2 Shaper Modeleur du signal audio avec une quantité variable de distorsion du 2ème ou du 3ème ordre. La quantité de distorsion et son type sont contrôlés par l’entrée “Shp”: Shp = 0 pas de modelage Shp > 0 modelage du 3ème ordre Shp < 0 modelage du 2ème ordre I.2. Audio Shaper > Broken Par Sat Saturation parabolique brisée. Segment linéaire autour du niveau zéro. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). L’entrée “H” règle la dureté (entre 0 et 1). Les valeurs plus grandes correspondent à un segment linéaire plus grand au milieu. L’entrée “S” contrôle la symétrie de la courbe de saturation (de –1 à 1). À 0, la courbe est symétrique. I.3. Audio Shaper > Hyperbol Sat Saturation hyperbolique simple. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). Cependant, la “saturation totale” n’est jamais atteinte avec ce type de saturation. 208 – REAKTOR CORE I.4. Audio Shaper > Parabol Sat Saturation parabolique simple. L’entrée “L” règle le niveau de sortie de la “saturation totale” (1 par défaut). Remarque: la saturation totale est atteinte avec un niveau d’entrée égal à 2L. I.5. Audio Shaper > Sine Shaper 4/8 Modeleur en sinus du 4ème / 8ème ordre. Le modeleur du 8ème ordre effectue une meilleure approximation du sinus, mais il consomme plus de puissance processeur. I.6. Control > ADSR Génère une enveloppe ADSR. A, D, R temps d’attaque, de décroissance (ou chute) et de relâchement (ou extinction) en secondes. S niveau de maintien (intervalle entre 0 et 1, à 1 le niveau de maintien est égal au niveau maximal). G entrée gate. Les évènements positifs entrants (re)démarrent l’enveloppe. Les évènements nuls ou négatifs arrêtent l’enveloppe. GS sensibilité du gate. Pour une sensibilité nulle, le maximum de l’enveloppe a toujours une amplitude de 1. Pour une sensibilité égale à 1, le maximum de l’enveloppe est égal au niveau du gate positif. REAKTOR CORE – 209 RM mode de redéclenchement. Commute entre les modes analogique et digital d’une part, et entre les modes redémarrage et legato d’autre part. En mode “digital”, l’enveloppe redémarre toujours de zéro alors qu’en mode “analogique” elle redémarre de son niveau de sortie actuel. En mode “redémarrage”, les évènements gate positifs redémarrent l’enveloppe, alors qu’en mode legato celle-ci redémarre seulement quand les gates passent d’une valeur négative/nulle à une valeur positive. Voici les valeurs de RM autorisées: RM = 0 redémarrage analogique (par défaut) RM = 1 legato analogique RM = 2 redémarrage digital RM = 3 legato digital I.7. Control > Env Follower Génère en sortie un signal de contrôle qui “suit” l’enveloppe du signal audio entrant. Les entrées A et D spécifient les temps d’attaque et de décroissance du suivi, en secondes. I.8. Control > Flip Flop La sortie est basculée entre 0 et 1 à chaque fois que l’entrée de commande reçoit un évènement. 210 – REAKTOR CORE I.9. Control > MultiWave LFO Génère simultanément en sortie plusieurs oscillateurs basse fréquence (LFOs) calés en phase, avec différentes formes d’onde. L’entrée Rate spécifie la fréquence en Hz, l’entrée W la largeur du train d’impulsions (dans l’intervalle de –1 à 1, valable uniquement pour la sortie “train d’impulsions”), les évènements à l’entrée Rst redémarrent les LFOs avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). I.10. Control > Par Ctl Shaper Applique une double courbe parabolique au signal de contrôle. Le signal d’entrée doit être dans l’intervalle [–1..1]. Le signal de sortie est aussi dans [–1..1]. La quantité de torsion est contrôlée par l’entrée “b” (dont l’intervalle est encore une fois [–1..1]). b=0 pas de torsion (courbe linéaire) b = -1 torsion maximale “vers” l’axe des X b=1 torsion maximale “vers” l’axe des Y Vous pouvez aussi utiliser ce modeleur pour les signaux dans l’intervalle [0..1], auquel cas seule une moitié de la courbe est utilisée. Usage typique: vélocité et autres modelages de contrôleurs. I.11. Control > Schmitt Trigger Passe la sortie à 1 si l’entrée devient supérieure à L+ (par défaut 0,67), et à 0 si l’entrée devient inférieure à L- (par défaut 0,33).. REAKTOR CORE – 211 I.12. Control > Sine LFO Génère un signal de contrôle basse fréquence sinusoïdal. L’entrée Rate spécifie la fréquence en Hz et les évènements à l’entrée Rst redémarrent le LFO avec la phase spécifiée par la valeur de l’évènement (dans l’intervalle de 0 à 1). I.13. Delay > 2/4 Tap Delay 4p Délai à 2/4 battements avec 4 points d’interpolation. Les entrées T1 à T4 spécifient la durée du délai (en secondes) pour chacun des battements. La durée maximale du délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. I.14. Delay > Delay 4p Délai à interpolation 4-points. L’entrée T spécifie la durée du délai en secondes. La durée maximale de délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. I.15. Delay > Diff Delay 4p Délai à diffusion à interpolation 4-points. L’entrée T spécifie la durée du délai 212 – REAKTOR CORE en secondes. L’entrée Dffs règle le facteur de diffusion. La durée maximale de délai est de 44100 échantillons par défaut, ce qui fait 1 seconde à 44,1 kHz. Pour ajuster cette durée, modifiez la taille du tableau dans la macro. I.16. EQ > 6dB LP/HP EQ Égaliseur passe-bas (LP) / passe-haut (HP) à 1 pôle (6 dB/octave). L’entrée F spécifie la fréquence de coupure (en Hz). I.17. EQ > HighShelf EQ Égaliseur à étage haut à 1 pôle. L’entrée dB spécifie l’accentuation des hautes fréquences, en dB (les valeurs négatives atténuent ces fréquences). L’entrée F spécifie la fréquence de transition, en Hertz. I.18. EQ > LowShelf EQ Égaliseur à étage bas à 1 pôle. L’entrée dB spécifie l’accentuation des basses fréquences, en dB (les valeurs négatives atténuent ces fréquences). L’entrée F spécifie la fréquence de transition, en Hertz. I.19. EQ > Peak EQ REAKTOR CORE – 213 Égaliseur à pic/creux à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, l’entrée BW spécifie la largeur de bande (en anglais bandwidth) en octaves, et l’entrée dB spécifie la hauteur du pic (les valeurs négatives produisant un creux). I.20. EQ > Static Filter > 1-pole static HP Filtre passe-haut statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz. I.21. EQ > Static Filter > 1-pole static HS Filtre à étage haut statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée B l’accentuation des hautes fréquences, en dB. I.22. EQ > Static Filter > 1-pole static LP Filtre passe-bas statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz. I.23. EQ > Static Filter > 1-pole static LS Filtre à étage bas statique à 1 pôle. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée B l’accentuation des basses fréquences en dB. 214 – REAKTOR CORE I.24. EQ > Static Filter > 2-pole static AP Filtre passe-tout statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). I.25. EQ > Static Filter > 2-pole static BP Filtre passe-bande statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, et l’entrée Res la résonance (entre 0 et 1). I.26. EQ > Static Filter > 2-pole static BP1 Filtre passe-bande statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, et l’entrée Res la résonance (entre 0 et 1). L’amplification à la fréquence centrale est toujours égale à 1, quelle que soit la résonance. I.27. EQ > Static Filter > 2-pole static HP Filtre passe-haut statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). REAKTOR CORE – 215 I.28. EQ > Static Filter > 2-pole static HS Filtre à étage haut statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res spécifie la résonance (entre 0 et 1) et l’entrée B l’accentuation des hautes fréquences en dB. I.29. EQ > Static Filter > 2-pole static LP Filtre passe-bas statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). I.30. EQ > Static Filter > 2-pole static LS Filtre à étage bas statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, l’entrée Res spécifie la résonance (entre 0 et 1) et l’entrée B l’accentuation des hautes fréquences en dB. I.31. EQ > Static Filter > 2-pole static N Filtre en creux statique à 2 pôles. L’entrée F spécifie la fréquence de coupure en Hz, et l’entrée Res la résonance (entre 0 et 1). 216 – REAKTOR CORE I.32. EQ > Static Filter > 2-pole static Pk Filtre en pic statique à 2 pôles. L’entrée F spécifie la fréquence centrale en Hz, l’entrée Res la résonance (entre 0 et 1) et l’entrée B l’accentuation à la fréquence centrale en dB. I.33. Oscillator > 4-Wave Mst Génère quatre formes d’onde audio calées en phase. Le pitch (hauteur tonale) de l’oscillateur est spécifié par l’entrée P (sous forme de numéro de note MIDI). Il peut être modulé par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée PW, dans l’intervalle de –1 à 1. Cet oscillateur peut fonctionner avec des fréquences négatives et dispose de plus d’une sortie de synchronisation pour l’oscillateur esclave équivalent, 4-Wave Slv. I.34. Oscillator > 4-Wave Slv REAKTOR CORE – 217 Génère quatre formes d’onde audio calées en phase. Le pitch (hauteur tonale) de l’oscillateur est spécifié par l’entrée P (sous forme de numéro de note MIDI). Il peut être modulé par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée PW, dans l’intervalle de –1 à 1.Cet oscillateur peut fonctionner avec des fréquences négatives. Il peut aussi être synchronisé à un autre oscillateur 4-Wave Mst/Slv via l’entrée Snc. L’entrée SncH contrôle la dureté de la synchronisation (0 = pas de synchro, de 0 à 1 = degré croissant de synchronisation souple). Une sortie de synchronisation pour un autre oscillateur 4-Wave Slv est également disponible. I.35. Oscillator > Digital Noise Générateur de bruit blanc numérique. Produit des valeurs aléatoires dans l’intervalle [-1..1]. Un évènement entrant à l’entrée Seed (ré)initialise le générateur aléatoire interne avec une valeur “graine” donnée (la valeur de l’évènement). I.36. Oscillator > FM Op Opérateur classique de FM (Modulation de Fréquence). Produit une onde sinusoïdale dont le pitch est défini par l’entrée P (en numéro de note MIDI). Le sinus peut être modulé en phase par l’entrée PhM (en radians). Un évènement arrivant à l’entrée Rst redémarre l’oscillateur à la phase spécifiée par la valeur de cet évènement (intervalle de 0 à 1). I.37. Oscillator > Formant Osc Génère une forme d’onde avec une fréquence fondamentale spécifiée par 218 – REAKTOR CORE l’entrée P (en numéro de note MIDI) et une fréquence de formant spécifiée par l’entrée Fmt (en Hz aussi). I.38. Oscillator > Impulse Génère une impulsion de largeur un échantillon, d’amplitude 1, en réponse à un évènement entrant. I.39. Oscillator > MultiWave Osc Génère quatre formes d’onde audio calées en phase. Le pitch (hauteur tonale) de l’oscillateur est spécifié par l’entrée P (sous forme de numéro de note MIDI). Il peut être modulé par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). La largeur de l’impulsion (pour le train d’impulsions) est spécifiée par l’entrée PW, dans l’intervalle de –1 à 1. Cet oscillateur ne peut pas fonctionner avec des fréquences négatives. I.40. Oscillator > Quad Osc Génère une paire de formes d’onde sinusoïdales calées en phase, avec un décalage de phase de 90°. L’entrée P spécifie le pitch, en numéro de note MIDI. REAKTOR CORE – 219 I.41. Oscillator > Sub Osc Génère quatre sous-harmoniques calées en phase. La fréquence “fondamentale” est spécifiée par l’entrée P (en numéro de note MIDI). Les nombres sous-harmoniques sont spécifiés par les entrées S1 à S4 (intervalle 1..120). L’entrée Tbr contrôle le contenu harmonique de la forme d’onde de sortie (intervalle 0..1). I.42. VCF > 2 Pole SV C Filtre 2-pôles à variable d’état (version compensée). Offre un meilleur comportement aux fréquences de coupures élevées. L’entrée P spécifie la fréquence de coupure (en numéro de note MIDI). Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle 0..0,98). Vous pouvez également utiliser des valeurs négatives de résonance, elles augmentent encore plus la pente. Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. I.43. VCF > 2 Pole SV T 220 – REAKTOR CORE Filtre 2-pôles à variable d’état avec compensation. Offre un meilleur comportement aux fréquences de coupures élevées, quoique légèrement différent de celui de la version 2 Pole SV C. L’entrée P spécifie la fréquence de coupure en numéro de note MIDI. Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle 0..1). Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. I.44. VCF > 2 Pole SV x3 S Filtre 2-pôles à variable d’état avec un suréchantillonnage optionnel (version x3) et une saturation. L’entrée P spécifie la fréquence de coupure (en numéro de note MIDI). Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle 0..1) et l’entrée Sat le niveau de saturation (intervalle typique: de 8 à 32). Les sorties HP/BP/LP produisent respectivement les signaux passe-haut, passe-bande et passe-bas. I.45. VCF > Diode Ladder Émulation linéaire d’un filtre à échelle de diodes. L’entrée P spécifie la fréquence de coupure du filtre (en numéro de note MIDI). Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle de 0 à 0,98). REAKTOR CORE – 221 I.46. VCF > D/T Ladder Émulation linéaire d’un filtre à échelle, fondu possible entre les comportements “diode” et “transistor”. L’entrée P spécifie la fréquence de coupure du filtre (en numéro de note MIDI). Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle de 0 à 0,98) et l’entrée D/T contrôle la balance entre les diodes et les transistors (0=diode, 1=transistor). I.47. VCF > Ladder x3 Une émulation d’un filtre à échelle de transistor saturant (suréchantillonné trois fois). L’entrée P spécifie la fréquence de coupure (en numéro de note MIDI). Elle peut être modulée par l’entrée PM (en demi-tons, donc exponentiellement) et par l’entrée FM (en Hertz, donc linéairement). L’entrée Res spécifie la résonance (intervalle de 0 à 1) et l’entrée SatL spécifie le niveau de saturation (intervalle typique entre 1 et 32). Les sorties 1 à 4 sont prises aux étages correspondants de l’échelle émulée. Prenez l’étage 4 pour le son de filtre à échelle “classique”. 222 – REAKTOR CORE Index B Boolean control (BoolCtl) ......... 113 C Cellules. Voir Cellules Core Cellules Core ............................ 11 (Re-)nommer les .................... 33 Audio .................................... 92 Dossier utilisateur des ............ 13 Édition basique des ................ 17 Évènements ........................... 66 Évènement et Audio................ 23 Générer des ........................... 25 Ports de ................................ 29 Utilisation des........................ 12 Comparaison de signe ............. 124 D Debug Mode ............................. 86 E Entrées. Voir Ports Signaux par défaut de l’entrée . 46 Évènements.............................. 60 Le routage des ..................... 112 simultanés............................. 63 Évènements Core. Voir Évènements F FP Precision .............. 45, 119, 146 H Horloge du taux d’échantillonnage ... ..... 73, 94, 96, 101, 110, 117, 136 I INF ....................................... 108 Initialisation ......................77, 126 Initialisation évènements ................ .................... 77, 89, 93, 108, 126 Inputs. Voir Ports L Latch module .........72, 74, 75, 83, .............................. 115, 123, 149 M Macros. Voir Macros Core Macros à modulation .......... 90, 93, ......................................123, 149 Macros Core ............................. 44 (Re-)nommer les .................... 45 Création de............................ 44 Dossier Utilisateur .................. 88 Paramètre Solid ............. 45, 101 Ports de ................................ 44 Macro Read [] ........................ 135 Macro Write [] ........................ 132 Mauvaises valeurs ........... 103, 108 Modules. Voir Modules Core Modules Core Insérer des ............................ 26 Ordre de traitement ................ 65 mode entier ..................121, 123 Module Denormal Cancel (DNC) 107 Module ES Ctl ........................ 126 Module Merge ..... 81, 83, 114, 150 Module R/W Order .................. 133 Module Read .............. 73, 80, 130 Initialisation de ...................... 77 Module Router .................112, 150 Module Write .......73, 80, 126, 130 Initialisation de ...................... 77 Module Z1 .....75, 96, 97, 111, 123 REAKTOR CORE – 223 N NaN ...................................... 108 O Object Bus Connections (OBC) ....... 73, 120, 129 P Ports Audio .................................... 92 Audio/Évènement ................... 19 Évènements ........................... 67 Générer ................................. 29 Ordre d’émission .................... 67 Ordre relatif ........................... 18 Précision de la virgule flottante. Voir FP Precision Q QnaN..................................... 108 QuickBus ................................. 35 QuickConst .........................47, 69 R Réinjection ............................... 95 Indication de ................... 42, 96 Réinjection et macros ............. 99 Résolution de .................97, 123 S Signaux audio .................................... 37 contrôle ................................ 37 entiers ........................ 120, 152 évènements ........................... 53 flottants .......................118, 152 Horloge. Voir Signaux d’horloge logiques ................................ 57 224 – REAKTOR CORE Signaux d’horloge ...................... 72 Signaux par défaut de l’entrée. Voir Entrées Sorties. Voir Ports Sorties Audio ............................ 93 Structure Core .......................... 18 T Tableaux ................................ 128 Tables.................................... 144 V Valeurs dénormales ................. 103