Primeros pasos con Reaktor - 2ª parte

Buenas de nuevo.

Aquí tenéis la segunda entrada de este pequeño tutorial para dar los primeros pasos con reaktor.

Con esta entrada vamos a empezar a meternos en líos, y como me da que va a resultar bastante densa, quería comentaros unas cosillas antes de empezar.

A medida que he ido escribiendo esta entrada, me he dado cuenta que hacía muchas referencias a capítulos de la entrada anterior. Esto en realidad no me termina de convencer, creo que ralentiza la lectura.

Sin embargo, no encuentro otra forma de seguir avanzando, ya que estamos viendo cosas muy básicas y de uso necesario para casi todo lo que puedes hacer con Reaktor, así que tendría que volver a explicarlas a cada paso que diéramos y el tuto acabaría con un montonazo de páginas y páginas repitiendo lo mismo.

Total, que la mejor solución que he encontrado es hacer referencia a los capítulos que ya se han explicado, como ya dije, y a cambio poner un índice de la entrada actual y todas las anteriores al principio de cada entrada. Como el índice dentro de poco sería enorme, voy a hacer una entrada solo para el índice que iré editando según vaya añadiendo partes, así podéis tener abierta la parte que estéis leyendo en una pestaña/ventana, y el índice en otra para revisar los capítulos que os hagan falta. Aquí lo tenéis.

Así todo, no os preocupéis, iré dejando de explicar poco a poco, las primeras veces os haré recordatorios además de la referencia, y según vaya avanzando iré dejando de dar estos recordatorios.

Seguramente más de uno ya se habrá dado cuenta, pero quiero señalaros que estoy usando, y seguiré usando, un formato específico para ciertas cosas.

Los menús siempre van en negrita y subrayados, además siempre sigo el orden en el que vais a tener que hacer click, separando con una flecha cada elección: File->Save ensemble.

Cuando nombro algún módulo (incluyendo todo, macros, instrumentos, módulos simples,...) específico, siempre lo escribo como un nombre propio, con la primera letra en mayúsculas, y en negrita. Y si al módulo le hemos cambiado el nombre, pongo el nombre tal cual lo hemos puesto, y en negrita. Igualmente, si hago referencia a pestañas, ventanas, o cualqueir cosa del Reaktor con un nombre específico, lo pondré tal cual sale en Reaktor, con mayúsculas, espacios, puntos y de todo, y en negrita.

Si ves una linea con guiones como esta...

----------------------------------------------------------------

... significa que empieza una parte de teoría, por un momento nos olvidamos del tutorial y explico algo en puros términos teóricos. Cuando se acabe la teoría pongo otra linea igual para los impacientes que quieran pasar de leerla ;) , o para los que ya sepan de qué va el tema.

Antes de empezar quería también comentaros que si tenéis cualquier duda, el mejor sitio para hacérmela llegar es el hilo oficial de Reaktor que tenemos en el subforo de Programación y Entornos , que sigo desde hace tiempo así que siempre me enteraré de que posteais.

Pues lista la intro, empezamos:

2. LO BASICO

2.1. ORDEN

Como iba diciendo, en la última entrada nos quedamos con un oscilador sin envolvente, así que funciona de manera continua, recogiendo el tono que indicamos vía teclado del ordenador o teclado MIDI, y una amplitud de onda seleccionable mediante un knob.

También te propuse que experimentaras con los distintos valores de las propiedades de este knob.

Antes de nada, para no perdernos, y para que yo pueda hacer referencia a ellos más fácilmente, vamos a ponerle un nombre a cada cosa.

Primero sube al último nivel, donde está la macro del instrumento:

Aprovecho para señalarte en rojo algo que ya vimos en el capítulo 1.4 de la última entrada: en esa esquina Reaktor siempre está diciéndote en qué macro/nivel estás. En el último nivel aparece el nombre del ensemble, ya que el último nivel ES el ensemble ;) … sí, ya sé que todo forma parte del ensemble, no solo el último nivel, pero fijate en este esquema:

Representa la estructura de un ensemble cualquiera: el ensemble es la caja donde metes todo, el último nivel; las macros son cajitas que puedes poner en cualquier sitio, incluso unas dentro de otras; los instrumentos son un tipo especial de macros que, la mayoría de las veces, te las vas a encontrar solo en la caja principal; los módulos son el nivel más básico, puedes encontrártelos en cualquier parte de la estructura y, como ya dije, son los que “hacen cosas“.

Esto puede parecer nimio u obvio, pero es importante que quede claro, porque si te pones a construir ensembles tarde o temprano vas a acabar con un número de módulos imposible de manejar en una misma pantalla, así que tienes dos opciones: organizarlo todo en macros y tener siempre una idea mínima de la estructura que estás haciendo, o volverte loco... y como siempre es mejor 10 macros con un par de módulos cada una, que 1 macro con 20 módulos dentro, es mejor que quede claro cómo funciona el concepto de estructura en Reaktor.

Dicho lo cual, estábamos en el último nivel de la estructura, con nuestro instrumento a la vista. Cámbiale el nombre como ya sabes hacer (doble click en la barra de título, y cambias el nombre en la barra de propiedades a la izquierda), y le vamos a llamar, por ejemplo, Sinte.

Ahora entra en Sinte (fijate que ahora en la esquina izquierda no aparece Instrument, sino Sinte), y repite la operación para la macro donde pusimos el oscilador, poniéndole el nombre OSC1, porque acabaremos haciendo más de un oscilador.

Cuando cambias el nombre no solo se actualiza la esquina de la ventana de estructura, también se actualiza el nombre que aparece en la ventana de panel.

Y te lo remarco porque el panel es la GUI de tu ensemble, cuando alguien vaya a usar el sinte (alguien como tú mismo, por ejemplo) solo con leer OSC1 ya sabrá que ahí dentro van los controles del primer oscilador, y es tan fácil como poner un nombre a la macro correspondiente.

2.2. ADSR

Bien, en este capítulo vamos a empezar con la chicha de verdad, y lo primero es añadir una envolvente para que el oscilador solo funcione cuando nosotros queramos y nos deje trabajar tranquilitos.

Ve a Sinte, añade una macro vacía como vimos en el capítulo 1.3 (menú botón derecho Macro->_New – Empty), y cámbiale el nombre por ADSR. Entra a la macro y añade los siguientes módulos:

• Una salida (recuerda, menú botón derecho Built-In Module->Terminal->Out port).

• Un módulo ADSR en el menú Built-In Module->LFO, Envelope->ADSR.

• Un módulo de gate en el menú Built-In Module->MIDI In->Gate.

----------------------------------------------------------------

Sé que acabamos de empezar, pero me voy a detener un rato en lo de la gate, porque si has toqueteado sintes modulares "lo de la gate" te sonará, pero a los que estén acostumbrados a tocar el teclado y que el sinte suene y listo, esta gate les va a sonar un poco a chino.

La cuestión es la siguiente, este modulo que ves en la imagen, envía un evento MIENTRAS estés apretando una tecla de tu teclado controlador, cuando sueltas la tecla deja de enviar. El valor del evento va de 0 a 1, y se corresponde con la velocidad, es decir, es la velocidad MIDI del teclado normalizada al intervalo [0,1] ; como la velocidad MIDI va de 0 a 127, simplemente divides la velocidad entre 127 y ya la tienes entre 0 y 1.

Y vamos con el ejemplo de rigor: presionas en tu teclado la nota Do4 con una velocidad MIDI de 100.

En el pianoroll de cualquier DAW del mercado obtendrías: por un lado la velocidad con un valor de 100, y por otro un mensaje MIDI de note on. Cuando sueltas la tecla, el DAW recibe un mensaje MIDI de note off.

En Reaktor, MIENTRAS estás presionando la tecla, el módulo gate envía un evento con valor 0,7874015 (y unos cuantos decimales más: 100 / 127 = 0,787401574803...), cuando dejas de presionar deja de enviar este evento.

¿Por qué es así y no con la velocidad MIDI de toda la vida, de 0 a 127?

Muy fácil: por que facilita enormemente los cálculos. Si multiplicas un número cualquiera por 1, el resultado es el mismo número, si lo multiplicas por 0,5 tienes la mitad, por 0,25 tienes un cuarto, etc.

Si recuerdas la analogía que hicimos en la anterior entrada, comparando el audio en Reaktor con la corriente de un río, si multiplicas esa corriente constantemente por 1, tendrás el mismo audio, si la multiplicas por 0,5 lo tendrás con la mitad de amplitud pero el mismo audio, y así hasta cero que no se oye nada.

Puedes comprobar todo esto en la web FooPlot. Esta utilísima página sirve para representar funciones gráficamente: si representas sin(x) en un color, y 0.5*sin(x) en otro color, verás que sigues teniendo la misma forma de onda pero con la mitad de amplitud.

----------------------------------------------------------------

Bueno, pues así funciona el módulo gate, y el módulo ADSR de Reaktor crea una envolvente a partir del valor que envía el gate:

Creo que la imagen es bastante clara: es una ADSR de toda la vida, el valor del evento que manda el módulo gate, está señalado en rojo, y determina el pico de amplitud más alto de la envolvente, según acabo de explicar en la parte de teoría.

Los demás valores del módulo son los típicos de una ADSR, así que añádelos rápidamente con el método que aprendiste en el capítulo 1.5 de la entrada anterior (pinchando sobre la letra de cada entrada con el botón derecho, y eligiendo el menú Create Control), después conecta la salida del módulo a la salida de la macro.

Solo señalarte que los valores de attack, decay y release, según te explica en la info de cada entrada (ya deberías saber cómo ver la info, pero te remito al capítulo 1.5 de la entrada anterior por si acaso ;) ), son logarítmicos: en la misma info te dice la correspondencia entre valores y milisegundos.

El sustain NO es logarítmico: igual que la gate, toma valores en el intervalo [0,1], y funciona también exactamente igual que la gate en cuanto a que modifica la amplitud multiplicando.

Bien, tenemos nuestra ADSR operativa, pero sin conectar al audio que envía el oscilador, así que vamos a salir de la macro y vamos a conectarlo.

Cuando salgas de la macro creo que vas a preguntarte cómo coño vas a conectar estas dos salidas de audio para que todo funcione. La respuesta está escondida en el tocho de teoría que puse antes, fijate que ahora mismo tenemos:

1- Un oscilador que está mandando audio continuamente a la “corriente” de audio, con un valor entre 0 y 1.

2- Una envolvente que manda audio solo mientras presionamos una tecla, con un valor entre 0 y 1.

Pues muy fácil: multiplicamos.

Si multiplicas, cuando la envolvente sea cero la amplitud de la onda será cero (no se oirá nada), cuando la envolvente vaya subiendo en el ataque la amplitud de la onda irá subiendo en proporción, en el tiempo de decaimiento irá bajando hasta el sustain, etc.

Si multiplicas, siempre tendrás la misma onda con una amplitud proporcional a la original, esta proporción es el valor del módulo ADSR.

Además, como las dos señales son de audio, los cambios serán a tiempo real a una frecuencia igual a tu sample rate... porque, como ya hemos visto, las señales de audio siempre están funcionando y Reaktor “las lee” a una frecuencia igual a tu sample rate.

Pues vamos allá: añade un módulo de multiplicación en el menú Built-In Module->Math->Multiply, y conecta las salidas de las macros OSC1 y ADSR, cada una a una entrada diferente del módulo (da igual a cual en concreto).

Ahora conecta la salida del módulo Multiply a los módulos con el símbolo {, no hace falta que desconectes lo que ya tenías antes, simplemente haz la nueva conexión y la vieja se borrará sola.

Verás en las imágenes que según voy conectando módulos, voy situándolos en la estructura, es algo que está entre manía mía :P y mantener un poco de orden para que se entienda de un vistazo el proceso que lleva el ensemble, de una forma más gráfica que teórica.

2.3. LO BASICO DEL PANEL

Si le echas un vistazo a la ventana de panel, verás que tienes un montón de knobs unos encima de otros, de hecho, hasta tienes una macro encima de la otra.

Vamos a arreglar esto ya mismo, porque según vayas añadiendo módulos y macros en la estructura, Reaktor va a seguir poniéndolos unos encima de otros en el panel, y es mejor dejarlo medianamente bien cuando todavía tenemos pocos. Los detalles para el final.

Para mover los módulos en la ventana de panel, debes pinchar en ellos y arrastrarlos hasta donde quieras ponerlos.

Sin embargo, si ahora intentas arrastrar los módulos no podrás moverlos... lógico, de no ser así, por ejemplo no podrías cambiar el valor de ningún knob ;)

Para eso está el botón de la llave inglesa de la barra vertical:

Si lo tienes sombreado, como en la imagen, tienes bloqueado el panel y NO puedes mover de sitio los módulos en el panel, pero sí puedes interactuar con ellos, cambiando el valor de un knob, por ejemplo.

Si por el contrario la pinchas y la dejas activada, tienes desbloqueado el panel y puedes cambiar de sitio los módulos, pero no puedes interactuar con ellos, exceptuando el botón derecho que siempre vas a poder usarlo.

Así que desbloquea el panel y vamos a separar las cosas, primero las dos macros: para mover las macros tienes que pinchar, o en el nombre, o en el cuadrado que la rodea. Observa la imagen:

La parte rodeada de un círculo rojo es el nombre de la macro, puedes pinchar ahí y arrastrar.

Las partes rodeadas con lineas rojas son el cuadrado que delimita la zona de la macro, también puedes pinchar ahí y arrastrar.

Dentro de ese cuadrado del que vengo hablando, el que delimita la zona de la macro, están todos los módulos visibles que pusiste dentro de la macro en la ventana de estructura. Por ejemplo, los knobs del ADSR estarán dentro del cuadrado titulado ADSR, y el knob de amplitud de onda estará dentro del cuadrado titulado OSC1. A esto me refería cuando te decía en el primer capítulo de esta entrada, que el panel es la GUI de tu sinte, y que por ello es muy importante nombrar las macros: si no las tuviésemos nombradas, ahora no sabríamos cual es cual.

Vale, ahora los módulos. En la macro OSC1 por ahora sólo hay un módulo, así que no tienes que hacer nada más. En la macro ADSR hay cuatro módulos que ahora mismo están unos encima de otros, y vas a tener que separarlos.

Es tan fácil como pinchar y arrastrar: uno a uno, vas arrastrando y colocando.

Si los knobs no te quedan alineados, usa la grid que se activa cuando desbloqueas el panel para alinearlos: cuenta los puntos que debería haber entre cada knob, y muevelos hasta que haya los mismos puntos entre cada uno.

Ahora que está todo visible y al alcance...

VUELVE A BLOQUEAR EL PANEL.

En serio, no puedo incidir lo suficiente en esto: siempre siempre siempre que hagas cambios en el panel, déjalo bloqueado en cuanto termines. No te imaginas la cantidad de veces que he ido a mover un knob, a apretar un botón o a cambiar el valor de una tabla, y he terminado teniendo que reorganizar la mitad de un instrumento porque se me había olvidado bloquear el panel.

Ahora que tienes pocas cosas en el panel puedes pensar que soy un poco exagerado, pero cuando tengas muchas ya veremos xD … hazme caso, VUELVE A BLOQUEAR EL PANEL.

De paso graba el ensemble, que nunca está de más: como en todos los soft, File->Save Ensemble As. No lo grabes como New porque perderás tu ensemble base: en mi ordenador lo tengo como Empezando, pero ya que no vamos a hacer referencia al nombre del ensemble, ponle el nombre que prefieras. Y si ya habías grabado y le pusiste otro nombre, pues también igual que en cualquier soft, File->Save Ensemble.

2.4. SWITCH

Este capítulo va a ser más largo y denso de lo normal, porque el switch es un módulo muy útil y con muchas peculiaridades, lo cual voy a aprovechar para explicar unas cuantas cosas y repasar otras que ya hemos visto.

Así que tómatelo con calma, ve poco a poco, y si te trabas, ya sabes: pregunta, que como decía un profe de mi cole, “el que no pregunta, no aprende” ;)

Bien, ahora que tenemos una envolvente, vamos a ponerle más tipos de onda al oscilador uno, que está muy soso.

Primero añade más módulos de osciladores dentro de la macro OSC1, teniendo en cuenta que todos los osciladores se encuentran en el menú Built-In Module->Oscillator. En realidad hay más osciladores en el menú Core Cell->Oscillator, pero nos iríamos al nivel Core de Reaktor y aún nos queda mucho para llegar a eso, así que usaremos los módulos Built-In de NI.

Por ahora vamos a intentar simplificar el sinte, que para complicarnos ya habrá tiempo, así que vamos a añadir cuatro módulos del menú Built-In Module->Oscillator: Triangle, Parabol, Sine y Pulse.

Si en vuestro monitor la ventana de estructura es demasiado pequeña, o simplemente no os sentís cómodos trabajando con el tamaño que tiene, la podéis hacer más grande pinchando en el borde superior, donde cambia la forma del puntero a una flecha doble, y arrastrando hacia arriba:

Vale, ahora sólo quedaría conectar el módulo NotePitch a las entradas de tono de cada oscilador y la amplitud a las correspondientes, las salidas son un problema.

Podrías sumar la salida de cada oscilador con un módulo de suma, pero funcionarían los cinco módulos a la vez y no queremos eso. Lo que queremos es:

1- Que funcione solo un módulo a la vez, para que el oscilador uno de nuestro sinte solo emita un tipo de onda concreto.

2- Poder elegir el tipo de onda que emite el oscilador uno, es decir, elegir qué módulo funciona.

3- Que el resto de los módulos no trabajen, para que no coman recursos innecesariamente.

Pues está claro que queremos un switch de toda la vida, que en Reaktor es el módulo Switch, tal cual, así que añádelo junto a los módulos anteriores usando el menú Built-In Module->Panel->Switch.

Si te has parado a pensar un poco te habrás fijado en que solo tiene una entrada y que la entrada es... ¡Verde!

Tenemos un nuevo tipo de entrada :P , bueno, ya la habíamos visto en el módulo Multiply pero no me detuve en ella, ahora me interesa señalarlo pero no te preocupes, esta es la más fácil así que el tocho de teoría es pequeñito, ni siquiera voy a poner la linea roja :P

Los módulos con entradas verdes sirven para todo, audio y eventos, puedes conectarles lo que quieras... pero el tipo de salidas de los “módulos verdes” dependerá de lo que hayas conectado a la entrada: si conectas audio el módulo también soltará audio, y viceversa. Además, para avisarte de esto, cuando conectes algo al módulo Reaktor cambiará el color de las entradas y salidas, así sabrás qué tienes conectado a ese módulo y qué está enviando. Prueba conectando la salida de un oscilador al switch, verás que la entrada y la salida se vuelven negras.

Aclarado esto, volvamos al módulo Switch que, como dije antes, solo tiene una entrada... y nosotros tenemos cinco osciladores que conectarle.

Esto es lo primero que tienes que hacer siempre que pones un módulo Switch en Reaktor: establecer el número de entradas.

Doble click al módulo Switch, en las propiedades (a la izquierda, recuerda) ve a la pestaña Function, y abajo verás un cuadro de texto con el nombre Min Num Port Groups:

Ese es el número de entradas de tu Switch, que por cierto es un cuadro de texto bastante especial: puedes cambiar su valor como si fuera un knob, o dándole doble click y escribiendo con el teclado. En realidad tú ya has visto otro cuadro de texto como este, solo que no te lo señalé: cuando añadimos el knob de amplitud en el capítulo 1.5.

Seguramente ya te habrás dado cuenta, si me hiciste caso y experimentaste con las propiedades del knob, pero te lo remarco porque en todos los knobs es igual: son las propiedades Num Steps y Mouse Reso.

Vuelvo al switch. Como tenemos cinco módulos a elegir, pon 5 en el cuadro de texto que te decía antes, Min Num Port Groups, y te aparecerán las cinco entradas.

Ahora voy a ir un poco rápido de nuevo, y te voy a decir las conexiones que tienes que hacer:

• La salida de cada oscilador a una entrada diferente de Switch.

• La salida de Switch al módulo Out.

• La salida del módulo NotePitch a la entrada P de todos los osciladores.

• La salida del knob Ampl a la entrada A de todos los osciladores.

Cuando acabes, separa y ordena un poco todos los módulos (también en el panel desbloqueandolo antes) para que no te hagas líos con las conexiones, y debería quedarte algo como esto:

Y ya en la foto te hago hincapié en dos cosas.

La primera, es que todavía te falta indicarle el ancho (la fase, el PW, como quieras llamarlo) para la onda de pulso, que, lógicamente, es la entrada W del módulo Pulse. Ya que todos sabemos lo que hace esto y por ahora no tiene mucha ciencia, añádele un knob con el método que hemos venido usando de botón derecho en la entrada y Create Control.

La segunda, es que te fijes en ese cuadrito que te señalo, en la esquina derecha de la barra de título del módulo de diente de sierra. Ahora mismo tiene el mismo color que el resto de la barra, eso significa que el módulo no está funcionando y no come recursos. No está funcionando porque no le has dicho al switch cual entrada debe funcionar, por tanto no funciona ninguna. Para arreglar esto basta con apretar un botón del switch en el panel, BLOQUEA EL PANEL si no lo has hecho ya ;) , y aprieta el primer botón.

Ahora el cuadrado del oscilador Sawtooth es amarillo (vamos, que “está encendido”), indicando que está funcionando, y en el resto de osciladores sigue siendo verde, no funcionan. Cada vez que le des a un botón diferente, se irá encendiendo el oscilador que corresponde a esa entrada.

De hecho, cuando un módulo deja de funcionar porque no es elegido por un switch, TODOS los módulos conectados a las entradas de este módulo, también dejarán de funcionar. Esto es como una cadena: cada módulo conectado al switch tiene su propia cadena de módulos antes que él, si el switch desactiva un módulo, también desactiva toda la cadena. En nuestro caso solo tenemos NotePitch y Ampl; Ampl es un knob, no necesita cuadrado porque es prácticamente solo un módulo visual, no sirve de mucho activarlo o desactivarlo; NotePitch por el contrario sí tiene cuadrado, a la izquierda, pero puedes darte cuenta de que está siempre activado elijas lo que elijas en el switch. NotePitch funciona así en nuestro caso porque está conectado a todos los módulos seleccionables desde el switch, por tanto, elijas el que elijas, siempre estará funcionando.

Puedes probar esto simplemente desconectándolo de un oscilador, si eliges este oscilador el cuadrado se apagará y el módulo se desactivará, si eliges cualquier otro oscilador el cuadrado se encenderá.

Mis dotes artísticas con paint no son dignas de mención precisamente xD, pero creo que se entiende: NotePitch se activa, solo cuando se activa un módulo al que esté conectado, de otra forma la cadena se rompe y queda desactivado.

Ah, después de probar no te olvides de volver a conectar NotePitch a la entrada P de Pulse.

Volviendo a nuestro Switch, las entradas están ordenadas de arriba a abajo, pero el que vaya a usar el sinte no verá la estructura, solo vería In In In... para cambiar ese texto solo tienes que cambiar el nombre a las entradas del módulo, igual que hacíamos con las entradas de las macros en el capítulo 1.3: doble click a la entrada, escribes y presionas Enter.

Ya que estás cambiando nombres, cambiale el nombre al módulo Switch, también como ya hemos visto (doble click en el cuerpo y propiedades), y ponle Wave.

Y aunque sea cuestión de gustos, a mí no me gustan los switch a base de botoncitos, un menú me resulta más práctico y ocupa mucho menos espacio en el panel, cosa que agradecerás más adelante. Esto se cambia en la pestaña View de las propiedades del módulo, abajo tienes un menú expandible que se llama Buttons, donde puedes elegir la apariencia del switch: elije Menu, aunque no está de más que le eches un vistazo a las demás opciones.

Seguramente al cambiar la apariencia del switch se te habrá descalabrado la anchura de la macro en el panel, porque el cuadrado que rodea las macros se hace más grande o más pequeño según los módulos que tengan dentro, para corregirlo es más fácil cambiar el tamaño del switch en los cuadros de texto Width y Height, que por cierto, son de los que vimos antes que funcionan también como knobs. No creo que haya mucho que explicar de esto, Width es el ancho y Height el alto, ajústalos hasta que te quede a un tamaño adecuado. Solo decir que estas propiedades están en prácticamente todos los módulos visibles, por razones obvias ;)

Una vez hechos los reajustes y todo bien colocadito, la cosa va teniendo buena pinta:

Pues por hoy creo que vamos listos con lo visto, y ya tenemos funcionando un oscilador con cinco formas de onda seleccionables y una envolvente de amplitud. Antes de hacer otra cosa, NO TE OLVIDES DE GUARDAR EL ENSEMBLE ;)

También podríamos haberlo hecho diferente, por ejemplo podríamos haber multiplicado la ADSR por el valor que envía el knob de Ampl, y el resultado mandarlo a la entrada de amplitud de los osciladores, o para los osciladores podríamos haber cogido módulos con capacidad de FM... pero bueno, poco a poco iremos añadiendo más cosas. Por tu lado puedes investigar todo lo que quieras, que eso nunca está de más, pero intenta grabar los experimentos en otro ensemble, así podemos usar éste solo para el tutorial.

No he visto la ocasión de hablar sobre las propiedades de los knobs como había prometido en la entrada anterior, y en esta creo que vas sobrado con el último capítulo, así que la próxima entrada empezaremos directamente con estas propiedades y seguiremos a partir de ahí.

Saludos.