Primeros pasos con Reaktor - 4ª parte

Por fin está lista la cuarta entrada, que ya iba tardando demasiado, y que es también, la segunda entrada dedicada a la GUI.

Aprovechando, os remito al hilo que he abierto específicamente para el tutorial, en el foro de Presentaciones y Avisos. Pasaos por allí si tenéis sugerencias o comentarios sobre el tuto.

Como ya sabréis, hace no mucho NI sacó la versión 5.6 de Reaktor, desde entonces he estado echándole un vistazo. No he encontrado bugs mayores, y si bien no es una actualización que represente un cambio enorme, añade algunas cosillas útiles, de entre las cuales, en mi opinión, la posibilidad de usar módulos XY con fondo transparente es la mejor.

Además, precisamente estábamos viendo en la última entrada estos módulos, así que aviso que a partir de esta entrada inclusive, voy a usar esta nueva versión.

En cualquier caso, si a alguien no le interesa actualizar por cualquier razón no va a tener problema alguno, los pantallazos tendrán algún detalle que no reconozcan en su Reaktor, pero nada que impida seguir el tutorial ya que, como dije antes, no ha habido grandes cambios.

Vamos con ello, pues.

4. MAS SOBRE LA GUI

4.1. MODULO XY. SEGUNDA PARTE, DEBERES

En la anterior entrada te dejé como deberes conectar correctamente el módulo XY que hicimos para controlar el Pan, además te propuse que intentaras hacer otro adecuado para lvl. Así que empezaremos la presente entrada resolviendo estas dos cosas.

Primero lo primero: ya tenemos hecho el pan, vamos a conectarlo a su sitio.

Así deberías tener la macro pan ahora mismo, el módulo XY funcionando, pero sin conectar a la salida. Y te señalo la esquina superior izquierda de la ventana de estructura, porque es una de esas cosillas útiles que se han añadido en la versión 5.6 de Reaktor: recordarás que antes en ese lugar había un desplegable con varias opciones de navegación, ahora se muestra la ruta de la macro que estás viendo en la ventana de estructura desde el mismo panel hasta la macro actual, pasando por instrumentos y cualquier tipo de macro.

Funciona igual que el explorador de windows 7, puedes pinchar en cualquier nombre de macro y te situarás en ella. Además, la ruta se conservará mientras tú sigas en cualquiera de las macros que aparecen en ella: si pinchas en Sinte la ruta sigue siendo la misma, así puedes desplazarte por cualquier macro de la ruta sin mover el ratón de esa esquina de la ventana. Una vez entres en una macro que no pertenezca a la ruta, entonces cambiará a la nueva que has elegido.

Explicado esto (me parecía lo suficientemente útil como para señalarlo), vamos al rollo.

La cuestión es entender cómo funciona el módulo XY. Seguramente ya has usado un pad XY en otros sintes virtuales, y todos funcionan igual, tal cual te expliqué en el tocho de teoría del capítulo 3.3: se envían dos datos correspondientes a las coordenadas X e Y del punto del pad donde pinchas (o aprietas si es un pad real, lógico). Me voy a extender un poco en esto, porque también sirve para otros módulos visuales de Reaktor, y porque en la entrada anterior me fijé más en el aspecto de los eventos y ahora quiero señalarte la parte más intuitiva.

Eso es un pad xy: un eje cartesiano de dos coordenadas. Cada coordenada es un valor que puede modular un parámetro cualquiera, de forma que cuando pinchas en el pad envía los dos valores que en la imagen represento con Cx y Cy, y esos valores se rutean al parámetro que deben modular.

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

Si eres de los estrictos, me dirías que el eje de coordenadas tiene que ser el mismo borde del pad, y tendrías razón, porque de otra manera cambian los valores Cx y Cy (si mueves el eje, la distancia al punto cambia, por tanto su coordenada cambia), pero esto no es un examen de mates ;) , ni una definición matemática estricta de un eje cartesiano de coordenadas; lo que buscamos es una definición intuitiva para así acercarnos al funcionamiento del módulo, y así se entiende mejor.

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

Sin embargo, hay una diferencia entre la imagen que te he propuesto y nuestro módulo XY para el canal de paneo: el pad de la imagen iría desde 0 hasta el valor máximo del módulo, el nuestro va de -1 a 1.

Para que veas la diferencia, ahí va otra imagen que se adecúa más a nuestro caso:

Ahora el eje está centrado en el pad, de forma que si pinchas en la mitad de la derecha tendrás un valor de X positivo, y si pinchas en la mitad de la izquierda un valor de X negativo. Si, como te había dicho en el capítulo 3.2, los valores para el pan son de -1 para todo al canal izquierdo, y +1 para todo al canal derecho, pues tienes una representación gráfica muy intuitiva del pan, que cualquiera va a entender a primera vista, y que depende solo del valor de X que envía el pad, que en nuestro caso es el módulo XY.

Ahí tienes la respuesta a los deberes, el pan se debería controlar con el valor X del módulo XY a través de su salida MX (capítulo 3.3 para recordar las salidas del módulo), y se controla efectivamente a través de la entrada Pan del módulo Stereo Mixer.

Por tanto, conecta la salida MX del módulo XY, a la salida de la macro pan, y la salida de esta última a la entrada Pan de cada uno de los dos módulos Stereo Mixer.

Te señalo también la macro en la que estamos a través de la esquina superior izquierda, para que te vayas acostumbrando a situarte en las macros con la ruta.

Ordenando todo un poco y borrando el knob antiguo que pusimos para el pan, debería quedarte algo como esto:

Fijate que he movido un poco nuestro módulo Pan en el panel, además de cambiar un poco el tamaño, para que encaje mejor visualmente en el recuadro de la macro Mix: arriba el nivel y centrado justo debajo de este, el “knob” que controla el paneo.

Llegados a este punto, paso a la segunda parte de los deberes: el módulo XY para controlar el nivel. Es muy fácil, solo tienes que “mover el eje”: si con el pan lo que nos interesaba era que el eje X fuera de -1 a 1, y nos olvidamos del eje Y, con el nivel es al contrario, queremos un eje Y que vaya de -50 a +12.

En la imagen verás que he añadido los mismos módulos que añadí para el módulo de paneo, le he cambiado el nombre al módulo XY nombrándole Level; le he puesto en las propiedades los valores mínimo y máximo -50 y +12; he cambiado la conexión del módulo Audio Smoother a la entrada Y2, y a la entrada X2 le he conectado la constante 1.

Los cambios en las conexiones a las entradas del módulo, vienen dados por el cambio en el eje que quieras hacer.

De entrada, no vamos a usar el valor de X (igual que antes no usábamos el valor de Y), así que ese eje no depende de dónde pinchemos, está siempre conectado a constantes.

Además, fijate que tal y como tengo el módulo ahora mismo, el punto (0,0) del eje de coordenadas está en el valor 0 decibelios, por tanto, el módulo va a dibujar la primera esquina del rectángulo en dicho punto, y la última donde pinches. Si pinchas en el valor más bajo, -50 decibelios, el módulo dibuja un rectángulo desde los 0 hasta los -50 decibelios, y el resto queda en negro.

A primera vista esto puede parecer algo bien hecho, sin embargo esto es un fallo, porque los faders de nivel nunca funcionan así, y cualquiera de nosotros, acostumbrados a todos los faders de los DAW, si vemos un fader dibujado de esta forma lo que vamos a pensar es que el fader está a 0 decibelios, no a -50.

Así que por muy bonito que quede, es un impedimento a la hora de usar el sinte... y precisamente esa es la razón por la que me detengo tanto en este tema: si entiendes que el módulo XY es un eje de coordenadas y cómo moverlo a donde te de la gana, podrás adaptarlo a cualquier requerimiento de tu sinte, haciendo que la estética sea algo que mejore su uso, no que lo sacrifique.

Por otro lado, si dejamos esto así estamos perdiendo exactitud a la hora de usar el módulo, porque si te fijas bien, el valor Stepsize ha cambiado a 0,31. Eso quiere decir que cada vez que movamos el módulo con el ratón, el siguiente paso estará a 0,31 decibelios, que no es algo muy aconsejable, porque a parte de que es una medida muy rara y nada intuitiva, es que ni siquiera vas a poder acertar en números enteros, por ejemplo a 0 decibelios.

Para que veas bien todo esto, coge una calculadora (la de windows también vale :P ) y haz esta operación: (50 / 0,31), cuyo resultado es 161,290322... y un montón de decimales más.

¿Recuerdas que vimos en el capítulo 3.1 que los knobs funcionan por pasos, y que cada paso es de una distancia igual a Stepsize? Pues ese es el problema que tenemos ahora, el módulo XY funciona igual, cada paso que das con el ratón supone 0,31 decibelios, así que para llegar desde -50 hasta 0 necesitas (50 / 0,31) pasos, osea 161,290322... pasos. Sin embargo, tú no puedes dar 161 pasos y después dar 0,290322 pasos, o das un paso o no das ninguno, no hay punto medio. Por tanto, tal y como tenemos ahora nuestro módulo XY, es imposible ponerlo en 0 decibelios, ni a +1 decibelios, ni a -25, ni a cualquier número que no sea múltiplo entero de 0,31... es decir, no puedes alcanzar casi ningún valor realmente útil, todos son decimales extraños.

Bien, dicho esto, hay varias formas de solventar estos problemas y seguir obteniendo un valor en (-50,12). La más fácil y rápida, pues está claro, cambiar el valor de Stepsize a uno más normalito, por ejemplo 0,5. Sin embargo esto no resuelve el aspecto visual, que es tan fácil de resolver como hacer que el módulo trabaje entre 0 y 62, y restarle al output 50.

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

Me gustaría detenerme un poco en otras formas de hacer este cambio, ya que voy a aprovecharlo por un lado para explicar más cosas, y por otro lado para que vayas haciéndote a una idea que vengo repitiéndote desde el principio del tutorial, y es que en Reaktor hay un montón de formas de hacer cada cosa, lo mejor que puedes hacer es buscar la tuya propia ;)

Pero bueno, para que lo tengas en cuenta y no entorpezca la lectura del tutorial, lo que voy a explicarte en este tocho de teoría no vamos a usarlo en nuestro sinte, es simplemente más conocimiento que dejo por aquí para el que lo quiera recoger.

Bien, otra forma de hacerlo es dejar el módulo en (0,1) y después escalar con la siguiente fórmula: F(x)=(62*x)-50.

Aprovecho para explicar esta fórmula que acabo de darte, y que viene de otra más general que puedes encontrar en la página que te di en la intro de la anterior entrada.

La fórmula sirve para escalar a cualquier intervalo, conociendo los valores máximo y mínimo de los intervalos de origen y destino, y es la siguiente:

F(x) = ((M' – m') / (M – m)) * (x – m) + m'

Donde:

• x = input o valor que quieres escalar

• F(x) = output o valor ya escalado

• m = mínimo del intervalo del input

• M = máximo del intervalo del input

• m' = mínimo del intervalo del output

• M' = máximo del intervalo del output

En nuestro caso específico el intervalo del input sería (0,1), y queremos un resultado entre (-50,12), que es el intervalo del output, por tanto:

F(x) = ( (12-(-50) ) / (1-0) ) * (x – 0) + (-50)

= ((12+50) / 1) * x – 50

= 62*x – 50

Esta fórmula es realmente útil, y aunque estrictamente el resultado que aporta es lineal y por tanto si buscas un resultado no lineal no sirve, habrán muchísimas veces que lo único que quieras sea cambiar de escala sin importar la linealidad del resultado, y otras en que no sea necesario un resultado exacto y una aproximación lineal sea suficiente.

Esto sería tan fácil como usar un módulo Built-In Module->Math->Mult/Add, a*b+c. Este módulo hace un par de operaciones matemáticas con las tres entradas que tiene, de arriba a abajo: multiplica las dos primeras entradas y al resultado de la multiplicación, le suma la tercera, siempre en ese orden. Con lo cual, conectando nuestro XY a una de las dos primeras entradas, una constante con valor 62 a la siguiente, y otra constante con valor (-50) a la última, se consigue la fórmula que acabamos de ver.

Otra forma sería normalizar también el módulo (pasarlo al intervalo (0,1) ), y conectarlo al módulo Built-In Module->Math->Log. (A), que cambia él solito un input en formato (0,1) a un output en formato decibelios.

De esto señalarte que en el menú Built-In Module->Math hay varios módulos para dos conversiones típicas: de decibelios a normalizado y viceversa, de frecuencia a tono y viceversa.

Unos se llaman Log y otros Exp, lo cual resulta intuitivo si consideras que la relación entre las dos medidas que te he comentado es logarítmica. El tono, pitch o notas, son logarítmicas con respecto a la frecuencia fundamental del sonido que representan; por otro lado, los decibelios son también logarítmicos con respecto a una medida normalizada, en el intervalo (0,1).

Ya que la función inversa del logaritmo es la exponencial, pues está claro: si quieres pasar de una medida a su logaritmo (de frecuencia a tono, de normalizado a decibelios), usas el módulo que tenga en el nombre Log; si quieres pasar de una medida que está en logaritmo a la otra, usas la inversa que es la exponencial, el módulo que tenga en el nombre Exp. Fácil ¿No? ;)

Así quedaría usando este módulo que acabamos de ver.

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

Solo quedan las conexiones al nivel de la macro Mix, que funcionan igual que las del pan pero conectadas a las entradas Lvl de los módulos Stereo Mixer:

4.2. VOCES. MONO Y MULTI

Para dejarlo todo bien terminado, vas a tener que añadir algo para saber en cuantos decibelios está el fader, porque, aunque el módulo XY podría mostrar por sí mismo el valor que se está eligiendo al presionar el botón del ratón (en las propiedades del módulo, pestaña VIEW, Show Value), en nuestro caso esto no nos va a servir por dos razones: primero, obvio, porque tenemos el módulo muy estrecho para que se asemeje visualmente a un fader, y como estos módulos muestran su valor en una barra superior de forma horizontal, queda fatal; segundo, porque el valor del módulo, como acabamos de ver, no es el valor de decibelios correcto que estamos aplicando; así que hay que hacer algo para mostrar ese valor de decibelios ya hecha la operación de restar 50.

Vamos a ello: añade en la matriz lvl, un módulo Built-In Module->Panel->Numeric Readout, conecta la salida del módulo de suma a la entrada del Numeric Readout, y vuelve a conectar la salida del módulo de suma (recuerda que puedes conectar las salidas a tantas entradas como quieras, pero cada entrada solo a una salida) a la entrada del módulo Out... ahora te van a pasar un par de cosas:

En esa imagen te he señalado unas cuantas cosas. Lo primero que tiene que saltar a la vista, es que el nuevo módulo (1) está mostrando un valor que no se corresponde con el elegido en nuestro módulo Lvl: tal como hemos hecho el módulo, es imposible que su valor actual sea 0, por tanto, no está funcionando correctamente.

Después, buscando el módulo en la ventana de estructura (2), verás dos cosas raras. Primero, la entrada está tachada con una cruz roja, que sin duda indica que algo no funciona correctamente, y segundo, verás que el cuadradito que tienen todos los módulos en la esquina inferior derecha, esta vez es naranja, no amarillo como en el resto de los módulos que hemos visto hasta ahora.

Hablando de esto, si seleccionas un módulo cualquiera, y en la pestaña FUNCTION de sus propiedades, marcas la opción Mono (3), el cuadradito amarillo pasará a ser naranja.

La conclusión es clara: el módulo Numeric Readout es siempre mono, solo admite una voz y, por tanto, si le conectas más voces no funciona.

Es lógico, un módulo que admita muchas voces también admitirá que le conecten módulos en mono, pero un módulo mono no admitirá módulos multi si no le dices qué voz específica debe coger. Para hacer esto hay otros módulos que separan los datos de las distintas voces, y también módulos que mandan datos por voces específicas, pero en nuestro caso esto no hace falta, ya que en realidad, tal y como estamos usando los módulos XY, deberían haber sido mono desde el principio.

Lo digo con tanta seguridad, porque lo que estamos haciendo son knobs, por mucho que sean módulos XY y todo lo que tú quieras, solo van a enviar un dato cada vez: el módulo Pan enviará UN número entre -1 y 1 cada vez que lo muevas, y el módulo Lvl enviará UN número entre 0 y 62 cada vez que lo muevas.

Un dato = mono. Intentar ponerlo todo en multi sería un desperdicio de recursos, es decir, de CPU, así que para evitar que se produzcan este tipo de errores entre conexiones por un descuido y no comerse recursos innecesarios, lo que toca es dejar TODA la macro, junto a TODO lo que hay en ella, en mono: tan fácil como subir de nivel, seleccionar la macro y marcar la casilla Mono que hemos visto en la última foto.

Y como puedes ver en esta nueva imagen, ya funciona el Numeric Readout. Si vuelves a entrar en la macro lvl, verás que la entrada de este módulo ya no tiene la cruz amarilla, porque ahora todos los módulos de la macro se han convertido en mono, y por tanto lo que le llega a la entrada es también mono.

Repite la operación con la matriz pan, que gastar recursos sin razón es algo que hay que evitar a cualquier precio.

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

No voy a extenderme mucho en este tema, porque es algo que, si acaso, veremos en la entrada de los eventos. Pero creo que es necesaria una breve explicación, por que no me gusta que te quedes solo con lo de "ponerlo todo en mono", sin saber el por qué de las cosas.

Las voces en Reaktor se controlan a nivel de instrumento. Si seleccionas un instrumento cualquiera, en la pestaña FUNCTION de las propiedades verás un recuadro titulado VOICE ALLOCATION.

No voy a detenerme a explicar las funciones que realiza cada opción de este recuadro, ya que están explicadas en los manuales, su nombre es bastante intuitivo e interesa más desde un punto de vista de usar los instrumentos, no de crearlos, pero es necesario que comprendas que cuando alguien (tú mismo) vaya a usar tu sinte o tu efecto, va a configurar las voces según le convenga. Desde luego, si haces un sinte, en algún momento querrás meterle un acorde o hacer más gordo un sonido, así que vas a darle caña a las voces.

Ya te lo imaginarás, pero Reaktor tiene que calcular cada una de las voces por separado. Cada uno de los módulos, conexiones, etcétera, que tú programes en la estructura, tiene que ser calculada, y si la dejas en multi, será calculada de nuevo por cada voz. Así que multiplica y te darás cuenta rápido que no puedes permitir que un módulo visual, que no tiene razón para usar más de una voz, te coma recursos como un loco porque un día tu necesitas 15 voces en vez de la única voz que usaste cuando probaste tu sinte.

En la estructura, las voces se pueden usar para llevar diferentes eventos y ahorrarte cálculos, para llevar más caudales de sonido, para un montón de cosas, pero hay que usarlas con cuidado, las necesarias, nada más.

Así, como acabo de decir, nos ahorramos sustos cuando necesitemos muchas voces para el propio sonido, que las voces comen CPU como locas.

Fijate que no te he dicho que pongas la matriz Mix en mono, y es que precisamente este es el momento de dejar que el usuario ponga las voces que quiera, así los módulos Stereo Mixer modificarán el nivel y el paneo de cada una de las voces que estén funcionando todas iguales.

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

Para dejar ya terminada la macro Mix, quita el título al módulo Numeric Readout, desmarcando la opción Show Label de la pestaña VIEW de las propiedades del módulo, y colócalo justo debajo del módulo Level, así se ve claro que corresponde a la lectura de decibelios.

Y con esto hemos terminado la macro Mix por ahora, así que solo queda conectarla a la estructura del sinte, que por cierto, en su momento le hicimos dos entradas, una para cada canal estereo, para posibles modificaciones del sinte, pero te recuerdo que ahora mismo la única parte estereo del sinte es precisamente esta macro, así que a la hora de conectarla...

... simplemente conecta la salida del módulo X (multiplicación) a las dos entradas.

De esta forma duplicamos el caudal de sonido, así que en pura teoría lo más correcto sería dejar solo una entrada, pero bueno, como después quizás añadamos algún efecto que necesite estereo, por ahora dejalo así, si hace falta ya lo corregiremos después.

4.3. BOTONES Y SWITCH

Ahora mismo, aún habiendo dicho que la macro Mix estaba terminada, yo diría que le falta un botón de mute, pero vamos a pensar esto un poco antes de añadirlo. Añade un botón en la macro Mix con el menú Built-In Module->Panel->Button, y ve a la pestaña FUNCTION de sus propiedades.

Verás que te he señalado dos títulos de las propiedades del botón: RANGE y MODE.

En el primero tienes dos valores: On Value es el valor que envía el botón cuando está apretado, Off Value es el valor que envía el botón cuando no está apretado, siendo los dos valores eventos. Esto tiene truco, porque como ya sabes, los eventos se mandan en momentos determinados, y con esto llegamos al segundo título, donde encuentras tres opciones a elegir una:

• Trigger que indica que el valor On Value se enviará solo al momento de apretar el botón, en ese momento se enviará un evento con valor On Value; visualmente, esto ocurre tan rápido, que al botón en el panel casi no le da tiempo de mostrarse apretado, mucho menos de cambiar de color.

• Si marcas la opción Gate, el módulo enviará un evento con valor On Value en el momento en que aprietes el botón (cuando le pinches encima sin soltar el botón del ratón), y un evento con valor Off Value en el momento en que sueltes el botón; visualmente, cuando pinches con el ratón se mostrará apretado y cambiará de color, y cuando sueltes el ratón volverá a su estado normal.

• La opción Toggle es un poco rara, en un principio es como Trigger, cada vez que pinches con el ratón el módulo enviará un evento, pero en Toggle el valor de este evento irá alternando entre On Value y Off Value cada vez que pinches el botón; visualmente, el botón se quedará apretado y cambiado de color cuando le toque al valor On Value, y en su estado normal cuando le toque el valor Off Value.

Si quieres usar un botón para mutear, solo tendrías que multiplicar el audio por la salida del módulo, poner el botón en Toggle e intercambiar los valores de On Value y Off Value que vienen por defecto, así al apretar el botón en el panel, el módulo enviaría un valor de 0, que multiplicado por cualquier otro número es 0; al dejar sin apretar el botón enviaría un 1, que multiplicado por cualquier otro número, es ese mismo número.

Quedaría algo así:

Esto funciona perfectamente (que por cierto, he aprovechado, he colocado el botón bien en el panel y lo he renombrado), pero tiene una pega porque, aunque funcione y no se oiga nada, el sinte sigue funcionando.

Como el muteado se produce justo antes de salir al daw/tarjeta de sonido, el resto del sinte sigue operando y, por tanto, consumiendo recursos. Así que, aunque funcione y sea fácil, no es lo más correcto... lo correcto sería que al mutear el sinte, dejara de funcionar completamente y de comerse CPU.

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

Si eres un poco avispado o si ya tienes muy claro el tema de los eventos, te habrás dado cuenta que esto no debería funcionar tan fácilmente, ya que en otros tochos de teoría como este ya te he comentado que los eventos solo se envían en un momento determinado. Si esto es así, y el botón solo manda el evento cuando lo aprietas, no debería mutear el sonido cuando dejas de apretar, porque pararía de mandar el 0 al módulo de multiplicación, y ya no tendría efecto sobre el audio.

Todo lo que te he dicho es correcto (puedes comprobarlo con la macro EventWatcher de CList, cuyo link de descarga te dejé en el capítulo 1.4), pero incompleto: el botón de mute funciona porque el módulo de multiplicación almacena el último evento que le envías, con lo que solo es necesario mandarle el evento una vez.

Esto se sale del tema de esta entrada, pero te adelanto que pasa con algunos módulos y con otros no. Por ejemplo, si pruebas con un módulo Built-In Module->Event Processing->Merge, no te pasará porque es un módulo preparado especificamente para pasar todos los eventos que pasen por todas sus entradas, a su única salida, y por tanto solo los manda en el momento en el que le llegan.

De todo esto no encontrarás ni una palabra en los manuales de Reaktor (yo al menos, no la he encontrado, y creeme, lo busqué la primera vez que tuve que enfrentarme a este tipo de cosas xD), razón por la cual estoy haciendo este tutorial... esta gente de NI...

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

Para que el sinte deje de comer CPU cuando le hagamos mute, vamos a usar un módulo que ya conoces, el Switch.

Como ya vimos en el capítulo 2.4, el módulo Switch te permite elegir una entrada de varias disponibles... y TODO lo conectado al resto de entradas deja de funcionar, como una cadena ¿Recuerdas? ;)

Si todo lo que está conectado a las entradas no elegidas deja de funcionar, es perfecto para un botón de mute, solo hay que hacer un Switch con dos entradas, a una le metemos el audio, y la otra la dejamos vacía: la vacía será la opción llamada Mute, para que cuando la elija el usuario, la otra entrada (con todo el sinte conectado a ella) deje de funcionar.

Y nada más empezar, tenemos dos problemas que ya os he señalado en la foto: primero, tenemos dos canales que deberíamos mutear al mismo tiempo, pero solo tenemos un switch; segundo, en el panel el switch no aparece como un botón de mute, aparecen dos opciones, y si bien una de ellas podemos dejarla sin título, así todo aparecen dos botones en vez de uno.

En esta entrada parece que los problemas y las pegas se reproducen cada vez que damos un paso, y nos pasamos el tiempo arreglándolos xD, y está perfecto, que de paso aprendemos unas cuantas cosas ;)

La forma de arreglarlo esta vez, es usando un par de cositas disponibles en los switch que no habíamos visto hasta ahora.

Primero ve a la pestaña VIEW de las propiedades del switch, desactiva la opción Show Label (esta ya deberías conocerla), y activa la opción 1 Toggle Button que se encuentra bajo el título Style.

Al desactivar la opción Show Label desaparece del panel la etiqueta del módulo, y al activar la opción 1 Toggle Button desaparecen todas las opciones menos la primera (por arriba), resultando, como su propio nombre indica, un único botón que alterna entre encendido y apagado (toggle). Cuando el botón está apretado, la opción elegida es la primera, fácilmente reconocible por su nombre; cuando el botón no está apretado, la opción elegida es la que queda. En realidad, la opción que elige cuando el botón no está apretado es siempre la última (la de abajo), pero bueno, nosotros solo tenemos dos opciones :P

Ahora duplica el switch (ya sabes, ctrl+d), haz no visible el nuevo (pestaña de propiedades VIEW, opción On bajo el título Visible) y conecta el otro canal a este nuevo switch.

Y ya tienes un switch por canal, ahora hay que hacer algo para que al apretar el botón mute del que es visible, también se elija la misma opción en el que no es visible.

Y vas a aprender una de las varias maneras que tiene Reaktor de hacer conexiones inalámbricas, osea, WIFI... jejeje, que sí, sin pasarte media hora uniendo entradas y salidas arrastrando el botón por media pantalla ¬¬ , de un módulo a otro sin cables.

Selecciona el primer switch, ve a la pestaña CONNECT de sus propiedades, y activa la opción que te señalo en la siguiente foto:

El simbolo de la opción es bastante intuitivo: un cuadrado (un módulo) sombreado (seleccionado) envía datos (la flecha) a un cuadrado no sombreado (módulo no seleccionado). Y eso es lo que acabas de hacer, decirle a Reaktor que este módulo que tenías seleccionado, va a enviar datos a otro módulo. Esto queda reflejado visualmente, porque el color del botón pasa de gris a blanco, y así sabes que este módulo está esperando que le digas a cual otro módulo va a enviar esos datos.

Ahora selecciona el segundo switch, el invisible, ve a su pestaña CONNECT de sus propiedades, y activa la opción que te señalo en la siguiente foto:

Que igual que antes, tiene un simbolo intuitivo, y además contrario al anterior: el cuadrado sombreado esta vez recibe datos del cuadrado no sombreado.

Haciendo esto le has dicho al módulo que estaba esperando, que los datos tiene que enviarlos a este otro módulo, así que en cuanto pinches el botón, a la izquierda te aparecerá la conexión que acabas de realizar (también te lo señalo en la foto), con el texto From Switch, es decir, Desde Switch.

Cada vez que hagas una conexión inalámbrica con este método, te aparecerá la conexión realizada en la pestaña CONNECT bajo el título INTERNAL & OSC CONNECTIONS, indicándote a qué módulo está conectado el módulo seleccionado y la dirección de la conexión. Si seleccionas el módulo origen, en la conexión aparecerá el texto To; si seleccionas el módulo de llegada, aparecerá el texto From; en ambos casos este texto vendrá acompañado del nombre del módulo que está en la otra punta de la conexión. Por cierto, si seleccionas la conexión que quieras (puedes hacer varias), y le das al simbolo de la papelera, la conexión se rompe.

Para verlo más claramente, prueba a cambiar de nombre el switch "invisible" (así no estropeamos el panel :P ) a destino, y observa esta pestaña CONNECT. Si seleccionas el módulo Switch, saldrá el texto To destino, si seleccionas el módulo destino, saldrá el texto From Switch.

Ahora sí que tenemos lista la macro Mix, y así todo, voy a darle un toque visual, que no me gusta ese botón de mute "en horizontal". Renombra el switch visible a Mute, ve a la pestaña VIEW de sus propiedades, desactiva la opción Show Port Labels y activa de nuevo la opción Show Label. Además, ahora que es un botón redondo y pequeñito, me parece que queda mejor encima del módulo Level, debería quedarte así:

Y con esto acabamos la cuarta entrada del tutorial, segunda dedicada al panel y los módulos visuales.

En realidad, en un principio quería meter en esta entrada un capítulo de las Stacked Macro, macros especiales y muy útiles. De hecho el capítulo está a medio hacer, pero como no he encontrado el sitio para usar una en nuestro sinte a estas alturas ( :S ), y como con este tutorial siempre tuve la intención de usar más práctica que teoría, lo dejo para cuando lo tengamos más avanzado y podamos añadirla al sinte para que haga algún trabajo.

No os preocupéis, que os lo debo y lo tendréis ;) . Mientras tanto, como siempre, os animo a que vayais investigándolas por vuestra cuenta :D

Solo resta adelantaros que la próxima entrada será iniciación al nivel Core, como hemos estado hablando en el hilo del tuto... os haré una confidencia... ¡Tengo unas ganas! Me encanta el nivel core XD

Hasta la próxima y saludos.