Native Instruments Reaktor 5 Manuel utilisateur

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 ([email protected])
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
[email protected]
www.native-instruments.de
Native Instruments USA, Inc.
5631 A Hollywood Boulevard
Los Angeles, CA 90028
USA
[email protected]
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
">