воркшоп

вообще всё компится через 2 основных саппорта: .tidal ; SuperDirt.

1) запуск SuperDirt
SD должен авто запускаться после лоуда прилы SuperCollider IDE. если нет, то в окне редактора SuperCollider IDE, пишем -

'SuperDirt.start'

и запускаем код нажатием кеев Cntrl + Enter (в то время как курсор на одной линии с кодом)

2) запуск Tidal Cycles

в вашем редакторе (Pulsar, vim, VS Code, итп), создайте новый файл и сохраните его с .tidal расширением (examples.tidal). Tidal должен автоматически запуститься, после запуска и выполнения команды.

бтв вы можете просто юзать Estuary. для начала как амулятор оч удобно. но будет доступ не ко всем возможностям редактора кода.

заметки/комменты в Haskell

тут это прикольно релизнуто. ничего лишнего: даблите — в начале строки и все. все че после дабла, интерпретатор игнорит. я это чаще юзаю, чтобы игнорить какую-то строку и иметь возможность вернуть ее в код без делита.

базовые паттерны

вщ овербейз вид создания звука выглядит около так:

но после 20 минут вы будете прописывать такие строки хоткееями.

вы можете остановить ЗВУК проекта, но НЕ САМ проект юзнувsilence:

вщ оверлей во всем проекте есть 2 варианта звуков, которые можно юзать вместе с базис-саундом: синты и семплы. если нужно юзнуть семпл, прописанный заранее, просто роутите до папки с ним. бэйз идёт первый в списке, но если пророутить до самого звука, с помощью : и номера, то юз будет именно он.

такж можно указать папку и сэмпл в 2 частях:

библио с семплами по умолчанию:

есть базисная библио с Dirt-Samples. в основном для написания чего-либо нужно будет импортить собственные сэмплы и роутить к ним. в Pulsar можно добавить настройки, которые загружают таб со всеми Dirt-Samples.

составьте последовательность:

чем больше в последовательности шагов, тем быстрее она выполняется:

прикольно оч, что работает именно так. это связано с тем, как Tidal обрабатывает время. cуществует универсальный цикл, который всегда работает. Tidal будет воспроизводить все звуки между речевыми знаками в одном цикле, если мы не укажем ему иного. вы также заметите, что Tidal равномерно распределяет звуки внутри цикла, что позволяет получать полиритмические структуры. можно изменять длительность цикла, используя setcps (где cps означает количество циклов в секунду) - это немного похоже на bpm (удары в минуту):

можно юзать d1, d2, d3...d9 чтобы воспроизводить несколько последовательностей одновременно:

чтобы стопнуть весь раш звуков - hush (или Cntrl+.)

можно остановить всё, изменив длину цикла на отрицательное число(главное заключить отрицательное число в скобки):

дальше запустить с положительным:

или можно использовать solo для конкретной строки:

а плагин Pulsar добавляет хоткеи:

Cntrl+1 - для мута первого паттерна

Cntrl+0 - анмутит все паттерны.

все хоткеи есть в паке самого Pulsar.

больше вариантов

можно добавлять фулл стоп или перерыв, с помощью ~:

добавлять предпоследовательность с помощью - []:

для более вариативного размера такта:

чтобы повторить паттерн - *

или используя / сделать обратное:

* работает ускоряя шаг, который воспроизводится. / работает обратно, замедляя.

оч помогают <> для планирования паттернов по циклам:

другие распространенные символы мини-обозначений: | - выбор случайного варианта, , - одновременное воспроизведение двух шаблонов и ! - воспроизведение шаблона.

эффекты

гласные

вщ можно юзать некст апы для изменения звучания. vowel - мейн фильтр, который может ченджить звучание - основные кодэйпы - a, e, i, o и u:

в самом проде эффекты = паттерны звуко. есть базисный нейм - паттерны контроля:

тут важно помнить, что можно юзать "<>"для планировки тейка по звукам:

такж если играться, можно добавить негласную букву(non-vowel), чтобы остановить свойства гласной(vowel):

Tidal будет авто сопоставлять звуки между друг другом:

можно потраить поменять параметры. структура воспроизведения будет идти слева:

усиление, высота тона(питч), панорама

усилиние(gain) может изменять громкость различных звуков:

скорость(speed) и нота(note) юзаются для того, чтобы задать высоту тона сэмплов. скорость(speed) влияет на скорость воспроизведения определённого тейка (напр. 2 = на октаву выше):

есть такж шаблон из параметра скорости:

up повышает тональность сэмпла на полутона (напр. 12 = выше на октаву):

панорамирование (pan) даёт возможность создавать стереоэффекты( 0 = left, 0.5 = middle, 1 = right):

дисторшн, ревёрб, делэй, фильтры

shape одна из функций, которая помогает для добавления дисторшна (но он очень сильно может искажать звук по громкости(нужна калибровка)):

делэй достигается за счет комбинации до четырех функций:

можно юзать lock 1, чтобы указать, что время, предоставляемое delaytime, указывается в циклах, а не в секундах.

все они получают паттерны:

для добавления эффекта reverb используйте функции dry, room и size:

также доступны несколько частотных фильтров: фильтр нижних частот, фильтр верхних частот, фильтр типа DJ и тд.

фильтр нижних частот:

фильтр верхних частот:

cutoff и hcutoff получают частоту в герцах точки среза. resonance и hresonance изменяются 0-1, но высокие значения резонанса могут привести к очень громкому звуку.

djf - более быстрый фильтр: он принимает число 0-1. при значениях меньше 0,5 это фильтр нижних частот, а при значениях больше 0,5 - фильтр верхних частот.

можете посмотреть тейк про эффекты

преобразование паттернов

вщ можно делать более сложные паттерны, используя преобразования. юзая такие функции, как slow, можно выйти за пределы цикла. функция slow растягивает паттерн на большее количество циклов:

медленно, быстро и поспешно

fast сжимает паттерн менее чем за один цикл. есть ещё density(это одно и то же):

hurry похожа на fast, но также применяет преобразование скорости:

доп инфу о времени, можно посмотреть во вкладке время.

реорганизация паттернов

вообще есть множество функций, которые можно использовать для изменения тейков. можно рассмотреть некоторые из них, но их гораздо больше. подробнее об этом написано в справочных разделах: изменение, накопление и условия.

можно изменить паттерн с помощью rev:

или воспроизведите его вперед и назад с помощью palindrome:

iter запускает шаблон с новой точки в каждом цикле, сдвигая его заданное количество раз, пока он не вернется в исходное положение:

every позволяет планировать преобразования или эффекты в разных циклах. пример будет воспроизводиться в два раза быстрее каждые четыре цикла:

... или вы можете запланировать эффект таким же образом, используя #:

jux (сокр. от juxtapose) берет преобразование или эффект и воспроизводит его в одной динамике, исходный паттерн воспроизводится в другой динамике:

chunk каждый раз применяет преобразование или эффект к разной части узора. если параметр равен 4, он будет проходить каждую четверть цикла.

еще больше про трансформацию

вообще можно преобразовывать более чем 1. можно объединить их вместе, используя .:

(почти) всё является паттерном, поэтому мы можем применять эти преобразования и к эффектам:

можете создать LFO на основе любого паттерна, используя fast или slow диапазон и осциллятор, например sine или saw:

по умолчанию такие осцилляторы, как sine, cosine или saw, выдают значения от 0 до 1. Этого достаточно для некоторых параметров (например, pan), но вы можете использовать range, чтобы масштабировать эти значения до любого желаемого вами диапазона.

в предыдущих примерах для каждого события запускается одно значение осциллятора. этого достаточно, если событий много за один цикл. однако, если событий меньше и они длиннее, необходимо выбрать несколько значений осциллятора для обеспечения плавного движения LFO. это можно сделать с помощью контроля управления:

здесь мы слышим, как звук постепенно меняется в течение цикла. существуют контроль управления для множества параметров, все они названы как «параметр плюс bus». в этом последнем примере segment 32 сообщает осциллятору о необходимости выбирать 32 значения в каждом цикле.

различные виды паттернов

циклический / повторяющийся

мы можем использовать n для выбора сэмплов из папки, это позволяет нам применять паттерны и там:

run - это краткий способ записи последовательных паттернов:

или

симметрия

полиметрические / полиритмические последовательности

можно воспроизвести две подпоследовательности одновременно, используя квадратные скобки (что-то типо одной большой подпоследовательности!), разделяя их запятой:

если использовать фигурные скобки вместо квадратных, эффект будет иным. с квадратными скобками обе половины последовательности вписываются в цикл (полиритмия). с фигурными скобками пульс задаётся левой частью последовательности. правая часть последовательности может затем перекрываться (или подкладываться!) (полиритмия):

Евклидов ритм/Бьорклунд

если вы укажете два числа в скобках после элемента паттерна, то Tidal попытается равномерно распределить первое количество звуков по второму количеству шагов:

эту штуку можно использовать внутри одного элемента паттерна:

вы также можете добавить третий параметр, который «поворачивает» паттерн так, чтобы он начинался с другого шага:

рандом

рандом может помочь быстро привнести характер и вариативность в паттерны. иногда это работает примерно так же, как и every, но вместо того, чтобы происходить после установленного периода, изменения имеют случайную вероятность появления:

often (75%) работает как sometimes (50%), но случается чаще:

irand генерирует случайное целое число до указанного числа. (например, для воспроизведения случайного сэмпла):

вы можете использовать degradeBy для удаления случайных элементов. число указывает вероятность воспроизведения сэмпла:

взаимодействие с сэмплами

пока что мы только короткие сэплы. вот что будет происходить в длинных сэмплах:

Tidal будет продолжать воспроизводить сэмпл в каждом цикле, даже если он очень длинный. даже если вы остановите воспроизведение паттерна, вам всё равно придётся слушать, как воспроизводятся сэмплы. вы можете использовать функцию cut, чтобы обрезать сэмпл при запуске следующего:

число в cut определяет группу, поэтому вы можете играть с помехами в разных паттернах:

legato также обрезает сэмплы, но используя фиксированную длину:

мы также можем нарезать сэмплы для получения эффекта гранулярного синтеза:

striate похож на chop, но организует воспроизведение по-другому:

randslice разбивает сэмпл на части, а затем воспроизводит случайную часть в каждом цикле:

можно использовать loopAt для фита сэмплов к заданному количеству циклов:

можно добавлять паттерны и преобразования к этим функциям или комбинировать их для получения интересных эффектов:

больше тут - "как управлять сэмплами"

синтезаторы

до этого юзались только сэмплы, но SuperDirt также поставляется со многими синтезаторами Supercollider, такими как superpiano, supersaw или superfm, также для краткости называемыми synths.

каждый из них имеет свои собственные функции и параметры, но в целом вы можете использовать их очень похожим образом, как и сэмплы:

можно управлять внешними синтезаторами по MIDI или OSC.

разница между функциями n и note

при использовании синтезаторов функции n и note абсолютно одинаковы: вы могли заметить, что в примере выше воспроизводятся ноты C, E (на 4 полутона выше C) и G (на 7 полутонов выше C). это то же самое, что:

при использовании сэмплов n обозначает индекс файла в папке сэмплов, отсортированный по алфавиту (по возрастанию) и отсчитываемый от 0 (нуля). каждый сэмпл может соответствовать ноте, если вы засэмплировали каждую ноту инструмента. однако при использовании note сэмпл изменяется по высоте (и соответственно изменяется его длительность).:

это позволит воспроизвести первый сэмпл из папки bd в нечётных циклах и пятый сэмпл в чётных циклах. в каждом цикле сэмпл будет воспроизведен 4 раза: один раз без изменений, один раз с повышением тональности на октаву (12 полутонов), один раз на квинту (7 полутонов) и последний раз на октаву ниже.

воспроизведение нот

большая часть этой доки/гайда посвящена ритму, но Tidal Cycles также предлагает способы игры нотами, гаммами, аккордами и арпеджио.

уже известно, как играть ноты: используя функцию note или, если у вас инструмент с понотным сэмплированием, выбирая ноты с помощью функции n.

также можно записывать ноты, используя систему обозначений Western Music Theory, которая использует первые 7 букв алфавита (от A до G). например, эти два кода эквивалентны:

названия нот в tidal просто преобразуются в номера, поэтому вы можете использовать любой из методов или оба одновременно.

после названия любой ноты можно добавить s или f для обозначения sharp и respectively соответственно. 0 и c относятся к ноте C пятой октавы. после названия любой ноты можно добавить номер октавы:

также может быть полезно перемещаться по октаве с помощью клавиш |+ или |-. это будет играть на третьей октаве:

чтобы узнать больше о том, как играть гаммы, аккорды и другое см. раздел звучание или инструкции по созданию арпеджио и взаимодействие с аккордами.

бб

эта работа стакает собственные наработки и наблюдения по TidalCycles + полный перевод документации на русский язык, чтобы сделать материал более доступным. в совокупности она показывает, что лайв-кодинг - это не только инструмент создания музыки, но и способ эксперимента, поиска новых звучаний и развития творческого подхода к звуку.

for supp:

GgMrVeeWdYBAj7NAA3Fp7jDUayYN86xqMZ3hqwGSRpvL (sol)

0x55352ba6e917ad7ec07bb2a8acc01c05c36c488d (evm)

чтобы увидеть список доступных аккордов, выполните команду import Sound.Tidal.Chords. эта команда импортирует внутренний список аккордов. команда chordList выведет список доступных аккордов, зарегистрированных Tidal.:

взаимодействие с аккордами

список выше можно объединить с тональностью, используя ' для использования с синтезаторами в Super Dirt, вот так:

также можно использовать сэмплы, настроенные на концертный C:

инверсию аккордов можно получить, добавив к аккорду символ ' вместе с одним или несколькими символами i. состояние по умолчанию, без i, соответствует основному тону. один символ i соответствует первой инверсии. вторая инверсия выглядит так:

количество нот в аккорде можно изменить, добавив к аккорду символ ' вместе с целым числом. в приведенном выше обращении аккорда можно сыграть 6 нот следующим образом:

открытую аппликатуру аккорда можно создать, добавив к нему 'o. это сместит первую и третью ноты аккорда на октаву ниже (обычно это Root и Fifth):

основной тон может быть установлен как sharp или flat с помощью s или f соответственно:

октаву можно задать числом. значение по умолчанию - 5:

аккорды можно записать с помощью оператора |+:

паттерн =:

справочник аккордов

полный список аккордов, доступных в Tidal, вместе с соответствующими нотами и альтернативными названиями:

арпеджио из нот

начнём с простой последовательности:

теперь воспроизведём по одному за цикл:

поверх этого поместите копию последовательности, смещенную по времени и тону:

добавьте немного структуры к исходной последовательности:

ревёрс в одном из динамиков:

давайте добавим еще один слой:

арпеджио из аккордов

начнём с C major аккорда:

используем функцию arp:

добавим ещё одну ноты в аккорд:

добавим другой аккорд:

изменим арпеджиатор:

паттернизируем арпеджиатор:

поменяем аккорды, добавим ревёрб:

и можно добавить вариативности с chunk :

• сигнатура типа: как функция объявлена ​​на стороне Haskell.
• описание: словесное описание функции.
• примеры: небольшой список примеров, которые можно скопировать и вставить в редактор.

скейлинг

функция scale преобразует последовательность номеров нот в определённую гамму.:

scaleList

функция scaleList выводит все доступные на момент написания статьи масштабы:

scaleTable

функция scaleTable выводит список всех доступных гамм и соответствующих им нот. например, её первый элемент - ("minPent",[0.0,3.0,5.0,7.0,10.0]), что означает, что минорная пентатоника образована root(0),the minor third(3 semitones above the root), the perfect fourth (5 semitones above the root) т.д....

поскольку список большой, вы можете использовать Haskell функцию lookup для поиска конкретного масштаба:

будет выводить - Just [0.0,1.0,3.0,5.0,7.0,8.0,10.0].

можно выполнить обратный просмотр таблицы масштабов:

в приведенном выше примере будут выведены все гаммы, первые три ноты которых - это тоника, большая секунда (на 2 полутона выше основного тона) и большая терция (на 4 полутона выше основного тона).

getScale

при желании вы можете создать собственную функцию scale с дополнительными шкалами, используя getScale:

в примере выше мы используем стандартную таблицу scaleTable в качестве отправной точки и добавляем к ней две пользовательские шкалы. вы сможете использовать новую функцию как обычно:

toScale

toScale позволяет быстро применить масштаб, не указывая его название:

аккорды

chordList

функция chordList выводит все доступные аккорды. на момент написания:

chordTable

функция chordTable выводит список всех доступных аккордов и соответствующих им нот. например, её первая запись - ("major",[0,4,7]), что означает, что мажорное трезвучие образовано root (0), the major third (4 semitones above the root)) и he perfect fifth (7 semitones above the root).

тк список большой, вы можете использовать функцию chordL для поиска конкретного аккорда:

:будет выводить (0>1)|[0,3,7,10]

если вы знаете ноты аккорда, но не можете найти его название, вы можете использовать этот код Haskell для обратного поиска в таблице:

:будет выводить [("dom7",[0,4,7,10])]

арпеджио

функция arpeggiate (= arpg) распределяет номера нот аккордов во времени. например:

rolled

функция roll не принимает аргументов и имитирует нисходящий рисунок игры струн на гитаре. ноты играются снизу вверх и равномерно распределяются в пределах (1/4) длительности события аккорда, в отличие от arp, который распределяет ноты по всему событию.

rolledBy

функция rollingBy работает так же, как и rolled, но позволяет указать часть события, на которую будут распределены заметки, или «длину» ролла.

модификаторы аккордов/голосовые тональности

существует множество различных модификаторов аккордов, предназначенных для изменения способа «звучания» аккорда (порядка нот, выбора октавы и т. д.).

количество аккордовых тонов

вы можете задать количество аккордовых тонов в аккорде. дополнительные тоны создаются путём проработки существующего списка тонов и их дублирования на октаву выше; уменьшение количества тонов вычитает элементы из списка аккордовых тонов, начиная с самых высоких нот. это также можно сделать по паттерну.

по умолчанию c'min9 содержит 5 аккордовых тонов [0,3,7,10,14] - мы можем увеличить это число до 8, то есть [0,3,7,10,14,12,15,19]:

мы можем сократить его до 4 аккордовых тонов (т.е. убрать 9), [0,3,7,10]:

открытый войсинг

это имитирует «открытое» фортепианное звучание, где первая и третья ноты аккорда понижены на октаву/12 полутонов, расширяя диапазон тонов аккорда на дополнительную октаву.

дроп n - войсинга

пониженные войсинга похоже на открытые, понижая N-ю самую высокую ноту в аккорде на октаву/12 полутонов. «drop 3» войсинг:

инверсия аккордов

аккорд инвертируется путём взятия самых низких нот аккорда N и повышения их на октаву/12 полутонов. это вторая инверсия для c'min9:

воспроизведение сэмпла питча

по умолчанию SuperDirt считает, что все сэмплы имеют высоту до C4 (MIDI-нота 60). воспроизвести сэмпл в тональном режиме просто, если звук действительно соответствует ноте C.

metatune

в WAV-файлы можно встраивать метаданные высоты тона в виде smpl chunk. это используется некоторыми сэмплерами для автоматического сопоставления сэмплов с MIDI-нотами. SuperDirt также считывает метаданные высоты тона всех загруженных сэмплов, позволяя корректно настроить их высоту тона (при условии корректности метаданных), установив параметр metatune в значение 1.

например, сэмпл bass1:18 из Dirt-Samples — это нота F2 (MIDI-нота 41) и помечен соответствующими метаданными высоты тона. с помощью metatune мы можем легко воспроизвести его в унисон с аккордом суперпиано:

можно редактировать с помощью различных инструментов. типа: pitcheon и LoopAuditioneer.

по сути, единственная задача Tidal Cycles - отправлять шаблонные сообщения OSC, чаще всего в аудиофреймворк SuperDirt. настроить Tidal для отправки OSC в другую систему довольно просто. для этого нужно указать, куда следует отправлять сообщения (цель), а также структуру отправляемых данных OSC (форму или формат сообщения).

расширенное руководство

определение цели

сначала, нужно определить цель:

метод планирования для oSchedule может быть одним из следующих:

• Live: заставляет Tidal планировать сообщения таким образом, чтобы они отправлялись в «правильное» время за вычетом значения oLatency. это самый простой подход, который будет работать хорошо в большинстве случаев.
• Pre BundleStamp: отправляет каждое OSC-сообщение, упакованное в «bundle» OSC с временной меткой пакета. Объединенные сообщения будут отправляться один раз в кадр пакетами, но с опережением времени (в соответствии со значением конфигурации oLatency). Tidal не пытается отправлять их с «правильным» временем, вместо этого от целевой системы ожидается точное планирование. это требует больше работы для целевой системы, но потенциально точнее, чем описанный выше вариант, поскольку позволяет избежать потенциального джиттера сети/обработки.
• Pre MessageStamp: аналогично BundleStamp, описанному выше, но временная метка добавляется к самому OSC-сообщению, заполняя два целочисленных поля «sec» и «usec».мнеобходимо явно включить их в список аргументов вашего формата osc (см. пример далее).

определение структуры сообщения OSC

далее определите структуру сообщения OSC. для начала стоит уделить немного времени ознакомлению со спецификацией OSC. существует два способа структурировать сообщения OSC, отправляемые Tidal: список аргументов или пары «имя-значение».

подход со списком аргументов наиболее распространён. он выглядит следующим образом:

чтобы определить структуру OSC, сначала укажите OSC, затем «адресс паттерна» OSC, в данном случае «/play». затем по порядку перечисляются аргументы сообщения. каждый аргумент представлен в виде «tuple», содержащего имя параметра и его значение по умолчанию.

в приведенном выше примере первый параметр «s» не имеет значения по умолчанию, на что указывает ключевое слово Nothing. это означает, что если параметр s не указан шаблоном, сообщение OSC не будет отправлено.

для остальных аргументов в примере значения по умолчанию указываются ключевым словом Just, за которым следует тип аргумента и его значение по умолчанию. VS задаёт значение по умолчанию как строку, VF — как число с плавающей точкой, а VI — как целое число. Другие доступные типы: VB для логических значений true/false (которые преобразуются в сообщении в целые числа 1/0) и VX для двоичных «blobs». если один или несколько из этих аргументов со значениями по умолчанию отсутствуют в паттерне, сообщение всё равно будет отправлено с этими значениями по умолчанию.

если вы используете Pre MessageStamp, вам необходимо добавить параметры сообщения sec и usec для их отправки:

помимо sec и usec, Tidal всегда заполняет ещё три параметра, если они есть: cps (циклы в секунду), cycle (начало события в циклах) и delta (продолжительность события в секундах). поэтому добавьте их, если хотите, чтобы эта информация была выведены:

названия параметров

вместо указания списка аргументов, как указано выше, вы можете указать названные параметры следующим образом:

при таком определении все параметры, указанные в паттерне, будут выведены. вместо фиксированных позиций в сообщении, как в случае со списком аргументов, параметры будут располагаться в произвольном порядке, но в виде пар «имя-значение». т.е., перед каждым параметром будет стоять дополнительный строковый параметр, задающий его имя. rак видно из примера, указан список «required» параметров - если все параметры, указанные в этом списке, не присутствуют в событии, заданном паттерне, оно не будет отправлено.

определение дополнительных параметров

многие параметры определены в Sound.Tidal.Params и доступны в сеансе Tidal. если вы хотите отправить параметры, которые ещё не определены, можно определить их самостоятельно. например, для параметра «intensity», использованного выше, необходимо задать следующее:

сопоставление структур сообщений с целями

последнее, что необходимо определить, - это соответствие между целями и принимаемыми ими структурами сообщений OSC. в данном случае есть только одна цель, принимающая только один тип сообщений OSC, поэтому всё просто:

стриминг и отправка паттернов

затем вы можете запустить 'stream' для преобразования шаблонов в OSC следующим образом:

и начать отправлять паттерн типо:

шорткаты

можно закатить клавиши так:

это будет работать так:

это очень похоже на определение d1, d2 и т. д. в BootTidal.hs.

вывод

вот целый код:

несколько целей и сообщений

можно организовать несколько сообщений OSC и отправлять их в несколько выводов из одного и того же «stream». например, чтобы стримить данные, отправленные как указанному выше получателю, так и в SuperDirt, можно сделать следующее:

bd будет отправлен как в target, так и в superdirtTarget.

сложные цели с несколькими форматами сообщений

некоторые OSC-цели более сложны, поддерживают несколько форматов OSC и также указывают данные в «address pattern» OSC. возьмём в качестве примера ASCII-Simple-Video-Synth. вот спецификация Tidal для него:

это программное обеспечение принимает ряд паттернов адресов, некоторые из которых включают цвет, к которому обращается адрес. чтобы сделать этот цвет паттерном, ему присваивается имя в фигурных скобках: "{asccolour}". затем это имя можно задать с помощью параметра 'ascColour' в паттерне Tidal.

при назначении нескольких форматов сообщений OSC потоку рекомендуется убедиться, что каждый формат имеет хотя бы один уникальный аргумент, отличный от значения по умолчанию. это гарантирует, что сообщения будут отправляться только при задании в шаблоне аргументов, отличных от значения по умолчанию. в противном случае для каждого события, заданного шаблоном, будут отправляться все форматы.

контроль ввода

сonfiguration

если вам нужен ввод только MIDI в Tidal, проверьте страницу MIDI в боковой панели.

после установки и настройки новейшей версии Tidal по умолчанию будет автоматически прослушивать внешние управляющие сообщения по сетевому протоколу OSC на локальном хосте (127.0.0.1), порт 6010. это можно настроить - например, если вы предпочитаете прослушивать все сетевые интерфейсы и порт 6060, вы можете изменить конфигурацию (BootTidal.hs) следующим образом:

если вы предпочитаете полностью отключить прослушивание элементов управления, используйте следующее:

сообщение OSC, ожидаемое Tidal, содержит путь /ctrl и два значения: ключ и значение. Ключ может быть строкой или целым числом (tidal автоматически преобразует целое число в строку). Значение может быть строкой, целым числом или числом с плавающей точкой. Например, сообщение OSC /ctrl sf hello 0.4 - это сообщение об установке элемента управления hello в значение 0.4. в этом примере sf — это тег типа OSC. он указывает, что первое значение - строка (s), а второе — строка (f)loat.

затем вы можете использовать этот элемент управления в следующем паттерне:

cF - это то, что используется для управления числами с плавающей точкой. второй параметр, 1, - это значение по умолчанию, если Tidal ещё не получил этот параметр. также существует cS для строк и cI для целых чисел. для значений времени (например, для использования в качестве первого параметра быстро/медленно) используйте cT. для отношений добавьте cR. если вы хотите получать целые паттерны (записанные в виде строки мини-нотации), используйте cP.

дебаггинг

один из способов отладки OSC - использовать анализатор пакетов, например WireShark. чтобы отфильтровать всё, кроме пакетов OSC, можно ввести osc в поле фильтра. если щелкнуть OSC network packet и раскрыть поля, можно увидеть корректно отформатированное представление сообщения OSC.

OSC SuperDirt API

вот как выглядит сообщение-триггер OSC от Tidal Cycles в SuperDirt

Рассмотрим этот паттерн: sound "bd" # speed 2. вот какое сообщение вида OSC генерируется:

он состоит из одного сообщения, упакованного в пакет, который содержит временную метку, указывающую, когда событие должно быть запущено. поскольку для цели OSC для Superdirt параметр oSchedule установлен на Pre BundleStamp, сообщения будут отправляться пакетами, заранее, и получатель (например, Superdirt) должен точно запланировать их отправку.

сообщение внутри пакета имеет путь /dirt/play и содержит переменное количество пар «имя-значение». можно видеть пары s bd и «speed 2», но Tidal добавляет несколько дополнительных пар. текущий cps, положение события в циклах (с момента запуска Tidal), delta или длительность события в секундах и номер orbit.

контроллеры воспроизведения

в некст разделе опишу доступные функции управления воспроизведением, и приведу пример использования MIDI-управления в SuperCollider для управления несколькими паттернами.

открытые функции управления звуком

отключить звук паттерна

вы можете отключить или включить паттерн, отправив сообщение OSC пророутив его с /mute или /unmute и аргументом, указывающим паттерн. как и в обычном коде tidal, это может быть число (для d1, d2 и т.д.) или строка (для именованных паттернов).

:сообщение OSC /mute 3 отключит d3.

контроль над всеми паттернами

можно управлять всеми паттернами воспроизведения, используя пути OSC /muteAll, /unmuteAll, /unsoloAll и, конечно же, /hush. все эти сообщения не имеют аргументов.

MIDI пример

вот полный пример SuperCollider для сопоставления кнопок MIDI-контроллера с паттернами, чтобы сообщения о включении/выключении нот от кнопок включали приглушение паттерна или запускали другие эффекты.

в этом примере используются MIDI-кнопки для нот C4 (значение MIDI 60), D4 и E4 для отключения звука на нотах d1, d2 и d3. ноты F4, G4 и A4 используются для включения solo на нотах d1, d2 и d3. также используется нота C5 для отключения звука всех нот, а нота D5 - для включения звука всех нот.

отредактируйте первый раздел кода (Mapping MIDI Controller), чтобы определить, какие кнопки контроллера вы хотите использовать для управления паттернами. остальной код должен работать с заданными вами назначениями и не требует редактирования, но может быть полезен для начала в проекте.

начните с уже запущенных Tidal (например, внутри Atom) и SuperDirt, а затем запустите следующий блок кода в SuperCollider:

// Оцените блок ниже, чтобы начать сопоставление MIDI -> OSC.
(
var mutes, solos, muteAll, unmuteAll, unsoloAll, hush;
var playbackControl, playbackState;
var osc;

/* — MIDI Controller Mapping ---------------------------- */
// Отредактируйте этот раздел, чтобы настроить свой MIDI-контроллер.

// "mutes" и "solos" представляют собой словарь номеров MIDI -> идентификаторы айди

// В этом кейсе, C4, D4 & E4 заглушаются паттерны d1, d2 & d3
mutes = Dictionary[
60 -> 1,
62 -> 2,
64 -> 3
];

// В этом кейсе, F4, G4 & A4 соло паттерны d1, d2 & d3
solos = Dictionary[
65 -> 1,
67 -> 2,
69 -> 3
];

// Тут MIDI note обращается к "muteAll"
// В этом кейсе, оно ставится C5
muteAll = 72;

// Тут MIDI обращается к "unmuteAll"
// В этом кейсе, оно ставится D5
unmuteAll = 74;

// Тут MIDI обращается к "unsoloAll"
// В этом кейсе, оно не используется
unsoloAll = nil;

// Тут MIDI обращается к "hush"
// В этом кейсе, оно не используется
hush = nil;

/* ------------------------------------------------------- */

playbackState = Dictionary[];

union(mutes.values.asSet, solos.values.asSet).do({
arg item;
playbackState.put(item, Dictionary[\mute -> false, \solo -> false]);
});

osc = NetAddr.new("127.0.0.1", 6010);

MIDIClient.init;
MIDIIn.connectAll;

playbackControl = MIDIFunc.noteOn({ |val, num, chan, src|
var patID, patState;
if (mutes.at(num) !== nil, {
patID = mutes.at(num);
patState = playbackState.at(patID);
if (patState.trueAt(\mute), {
osc.sendMsg("/unmute", patID);
patState.put(\mute, false);
}, {
osc.sendMsg("/mute", patID);
patState.put(\mute, true);
});
});

if (solos.at(num) !== nil, {
patID = solos.at(num);
patState = playbackState.at(patID);
if (patState.trueAt(\solo), {
osc.sendMsg("/unsolo", patID);
patState.put(\solo, false);
}, {
osc.sendMsg("/solo", patID);
patState.put(\solo, true);
});
});

if (muteAll == num, {
osc.sendMsg("/muteAll");
playbackState.do({
arg patState;
patState.put(\mute, true);
});
});

if (unmuteAll == num, {
osc.sendMsg("/unmuteAll");
playbackState.do({
arg patState;
patState.put(\mute, false);
});
});

if (unsoloAll == num, {
osc.sendMsg("/unsoloAll");
playbackState.do({
arg patState;
patState.put(\solo, false);
});
});

if (hush == num, {
osc.sendMsg("/hush");
});
});

if (~stopMidiMuteControl != nil, {
~stopMidiMuteControl.value;
});

~stopMidiMuteControl = {
playbackControl.free;
};
)

// оцените строку ниже, чтобы остановить это.
~stopMidiMuteControl.value;

SuperDirt MIDI

Предварительные условия

Для установки требуются последние версии Tidal и SuperDirt:

• Обновитесь до последней версии Tidal
• Убедитесь, что у вас установлена ​​последняя версия SuperDirt Quark. Проще всего удалить и переустановить SuperDirt Quark. подробнее об обновлении Quark - тут.

Инициализация

для начала вам нужно запустить SuperCollider. сначала запуск SuperDirt как обычно. затем в SuperCollider выполните следующий код:

теперь в окне поста SuperCollider должен появиться список системных MIDI-устройств. вывод будет выглядеть примерно так:

названия этих MIDI-устройств состоят из двух частей. обе части понадобятся вам на следующем этапе - для подключения к MIDI-устройству. нужно проверить следующую строку:

тут мы сохранили ссылку на устройство в переменной ~midiOut.

И наконец, определиям имя «синтезатора» в Tidal, который будет использоваться для управления этим устройством. ниже мы назовём его mydevice. выполняем следующую команду:

при желании вы можете определить значение задержки на вашем устройстве:

на этом инициализация завершена. теперь у есть MIDI-устройство, подключенное к SuperDirt и работающее как синтезатор с именем mydevice.

Использование в Tidal

примечание по паттернам

теперь можно начать писать паттерны Tidal для управления MIDI-устройством. можно отправить ему простой нотный паттерн:

это должно воспроизвести простой паттерн из четырёх нот. обратите внимание, что мы используем имя синтезатора mydevice для отправки нот на MIDI-устройство.

также можно использовать имя ноты и октавную нотацию:

в качестве альтернативы использованию n или note для передачи MIDI-нот вы можете использовать функцию midinote:

единственное отличие заключается в том, что в midinote ноты обозначаются числами от 0 (C(-1)) до 127 (G9). В Tidal Cycles нота 0 — это C5, а в MIDI C5 — это нота 60, поэтому перевод из одной системы в другую легко осуществить, прибавляя или вычитая 60 к длительности ноты.

последний пример можно переписать так:

MIDI каналы

используйте функцию midichan для настройки MIDI-канала.

MIDI-канал по умолчанию - 1. MIDI-каналы SuperDirt индексируются, начиная с нуля, поэтому MIDI-канал 1 - это midichan 0:

если ваш синтезатор обрщается к другому каналу, скажем, MIDI-канал 5, вам следует использовать midichan 4:

midichan принимает паттерн из цифр, поэтому вы можете использовать паттерн для воспроизведения на разных каналах MIDI:

приведенный выше шаблон воспроизводит ноты «0 2» на канале 1 и «4 7» на канале 5.

CC Params

чтобы отправить параметр CC на синтезатор, в новом MIDI SuperDirt лучше всего использовать другой паттерн Tidal. для создания этого паттерна вам понадобятся два новых MIDI-параметра SuperDirt:

• ccn: номер параметра CC, которым вы хотите управлять: ccn 30
• ccv: значение для отправки в параметр CC, в диапазоне от 0 до 127: ccv 64

вот полный пример, отправляющий значение 64 в параметр CC 30:

также можно указать MIDI-канал с помощью midichan:

можно указать шаблоны значений CC:

обратите внимание, что в данном случае при использовании символа # ритм задаётся самым левым паттерном.

если на вашем устройстве есть функция, которая прослушивает определённый номер CC, вы можете присвоить понятное имя:

если есть много параметров CC, которыми вы хотите управлять одновременно, хорошо подойдет стек:

каждое устройство имеет собственную реализацию MIDI-диаграммы, но есть несколько стандартных номеров CC, которые должны работать одинаково на большинстве устройств:

существует также функция cc, которая позволяет передавать и число, и значение в одной строке:

cкорость

cкорость нажатия по MIDI можно задать с помощью параметров amp и gain. они работают аналогично сэмплам: amp, а gain.

Скорость нажатия по умолчанию - 50, amp - 0,4, а gain - 1.

в таблицах показано, как различные значения amp и gain влияют на скорость нажатия:

модуляция высоты тона

модуляцию высоты тона можно контролировать с помощью функции midibend.

обычно колесо высоты тона передаёт число в диапазоне от -8192 до 8191, но здесь все числа положительные, поэтому диапазон составляет от 0 до 16383, где 8192 - нейтральная средняя точка.

можно имитировать движение колеса высоты тона различными способами.

предположим, ваше устройство называется mydevice и принимает MIDI-сообщения по каналу 5. в этом примере звук начнётся с ноты C и постепенно будет увеличиваться до предела модуляции высоты тона:

теперь мы начинаем с минимума модуляции высоты тона и быстро движемся к нейтральной точке, где мы будем поддерживать высоту тона до конца цикла:

ретушь

ретушь используется для изменения характера воспроизводимого звука, обычно путём увеличения или уменьшения нажатия на клавиши клавиатуры MIDI-контроллера.

для передачи MIDI-сообщений ретушь на устройство используется функция miditouch.

диапозон 0 - 127, а дефолтное значение - 0.

в этом примере после воспроизведения ноты мы устанавливаем ретушь от 0 до 64 и обратно несколько раз в цикле, как если бы была нажата клавиша C MIDI-контроллера.

колесо модуляции

специальной функции для отправки сообщений колеса модуляции не существует, но для колеса модуляции используется CC 1, поэтому можно юзать это:

здесь мы начинаем цикл с mod wheel, установленным на 0, поднимаемся до максимума, затем опускаемся до минимума и снова заканчиваем цикл на 0.

изменение программы

сообщения об изменении программы можно отправлять с помощью функции progNum.

если вы назвали свое устройство mydevice и оно получает сообщения об изменении программы по MIDI-каналу 14, вы можете изменить его программу/паттерн, выполнив следующую команду:

NRPN парамаетры

для отправки параметров NRPN используйте функции nrpnn и nrpnv.

номера NRPN состоят из двух байтов: старшего байта (MSB) и младшего байта (LSB). при использовании nrpnn эти два байта записываются в одно число. чтобы рассчитать необходимое число, умножьте первый байт (MSB) на 128, а затем прибавьте второй байт (LSB). Например, если в руководстве к вашему устройству указано, что отправка реверберации задаётся значениями NRPN MSP 2 и NRPN LSB 6 (или 2:6), вам нужно указать для nrpnn значение 2*128+6=262.

значения NRPN также состоят из двух байтов, что обеспечивает большую точность, чем сообщения CC. допустимый диапазон для nrpnv - от 0 до 16384. однако учтите, что многие устройства просто проигнорируют эту дополнительную точность.

nrpnn и nrpnv являются шаблонными, но обратите внимание, что их аргумент имеет тип Pattern Int, поэтому нужно убедиться, что вы передается значения типа Int, а не Double:

sine возвращает нам значения типа Double, поэтому нам нужно преобразовать их в Int перед передачей в nrpnv. для этого мы используем floor - функцию Haskell, округляющую число в меньшую сторону, и <$>, которая применяет функцию (в данном случае floor) ко всем элементам коллекции.

существует также функция nrpn, которая позволяет нам передавать и число, и значение в одной строке:

Синхронизация MIDI-часов

часто бывает важно отправлять события MIDI-синхронизации для синхронизации темпа между устройствами. Tidal не может синхронизировать свой темп с получаемыми событиями MIDI-синхронизации, но может выступать в качестве источника MIDI-синхронизации. в следующих разделах показаны два варианта отправки событий MIDI-синхронизации, соответствующих темпу Tidal.

синхронизация MIDI-часов с использованием протокола Link

начиная с версии 1.9, Tidal использует протокол Link для планирования событий. Link — это технология, синхронизирующая музыкальный ритм, темп и фазу в нескольких приложениях. изначально она была разработана компанией Ableton, но имеет открытый исходный код и теперь реализована во многих музыкальных программах. можно использовать Link для синхронизации Tidal с отдельной программой, которая будет выступать в качестве источника MIDI-сигнала.

это предпочтительный метод отправки событий MIDI-синхронизации, поскольку он прост, производителен, стабилен.

SuperCollider как источник MIDI-синхронизации

можно использовать Link для синхронизации Tidal с SuperCollider и настроить SuperCollider на отправку MIDI-событий. для этого потребуется расширить SuperCollider новым классом LinkToMidiClock.

найдите соответствующий каталог расширений, выполнив одну из следующих строк в SuperCollider:

создайте файл LinkToMidiClock.sc в выбранном каталоге расширений и сохраните его со следующим содержимым:

перезагрузите SuperCollider или используйте Language > Recompile Class Library

теперь можно следовать руководству по инициализации. будем использовать переменную MIDI-устройства с именем ~midiOut из инициализации в примерах ниже.

После инициализации MIDI-устройства создайте LinkClock в SuperCollider.

убедиться, что Tidal и SuperCollider соединились по Link, можно, проверив количество peers Link:

затем создайте LinkToMidiClock, подключенный к MIDI-устройству ~midiOut и LinkClock ~lc.

события MIDI-синхронизации будут отправляться непрерывно после того, как мы пропишем их начало, до тех пор, пока мы не пропишем их остановку.

контроль входа звука

Tidal 1.0.0 теперь поддерживает внешний входной сигнал по протоколу OSC. вот краткое руководство по настройке, включая использование простого «бриджа» для работы MIDI-входа.

сет-ап

чтобы использовать MIDI, вам не нужно особо беспокоиться о сопоставлении OSC. однако вам потребуется запустить программу для преобразования MIDI в OSC (Tidal слушает сообщения OSC). вот как это сделать с помощью SuperCollider. сначала, когда Tidal и SuperDirt уже запущены, запустите следующий блок кода в SuperCollider:

сет-ап в использовании

после этого вы сможете запустить следующий паттерн, использующий CC value 12:

если вы хотите использовать MIDI в операторе формирования паттернов, может быть полезно сначала segment входные данные, поскольку исходный паттерн, поступающий с вашего MIDI-устройства, будет иметь очень высокое разрешение. в этом примере принимается только одно значение за цикл, которое затем преобразуется с помощью функции range:

базовые инструменты

значения по умолчанию указаны в скобках. во всех синтезаторах sustain (по умолчанию 1) влияет на общую временную шкалу огибающей. Параметры pan и freq также можно настроить во всех синтезаторах. значение freq по умолчанию обычно равно 440. В синтезаторах, где это значение отличается, freq и его значение по умолчанию для данного синтезатора указаны в списке параметров ниже.

добавочный синтез

supergong

Пример добавочного синтеза, создающего гонгообразный шум из суммы гармоник синусоидальной формы. тут видно, как временная шкала огибающей и амплитуда могут масштабироваться в зависимости от частоты гармон.

• voice (0): обеспечивает что-то вроде ручки тембра
• decay (1): регулирует затухание гармоник
• accelerate (0): для плавного изменения высоты тона

Субстративный синтез

supersquare

синтезатор square-wave формы; импульсы переменной ширины с частотой фильтра, модулируемой LFO:

• voice: управляет шириной импульса (точно ноль или единица не воспроизводит звук).
• decay (0): затухание.
• accelerate (0): плавное изменение высоты тона.
• semitone (12): насколько сильно вторичный осциллятор отклоняется по высоте тона (не обязательно целое число).
• resonance (0.2): резонанс фильтра.
• LFO (1): степень влияния LFO на частоту фильтра.
• rate (1): частота LFO.
• pitch1 (1): множитель масштабирования частоты фильтра, сама частота следует за высотой тона, заданной параметром «n».

superpwm

cинтезатор PWM; импульсы умножаются на сдвинутые по фазе импульсы, двойная фильтрация с огибающей на второй частоте.

• voice: управляет скоростью сдвига фазы.
• decay (0): затухание.
• accelerate (0): плавное изменение высоты тона.
• semitone (12): насколько далеко по высоте тона находится вторичный осциллятор (не обязательно целое число).
• resonance (0,2): резонанс фильтра.
• lfo (1): степень влияния LFO на частоту фильтра.
• rate (1): частота LFO.
• pitch1 (1): множитель масштабирования частоты фильтра, сама частота следует за высотой тона, заданной параметром «n».

superchip

использует эмуляцию Atari ST UGen с 3 осцилляторами:

slide (0): для линейного скольжения частоты
rate (1): повторяет указанное выше скольжение n раз (может быть дробным или отрицательным)
accelerate (0): для полного скольжения
pitch2 (2): управляет соотношением гармоник
pitch3 (3): управляет соотношением гармоник
voice (0): вызывает изменения уровней трёх осцилляторов

superzow

• decay (0): для формирования огибающей
• accelerate (0): для изменения высоты тона
• slide (1): скорость перемещения по фазе
• detune (1): для расстройки осциллятора

supertron

фидбэчит PWM:

• accelerator (0): плавное изменение высоты тона
• voice (0): количество голосов
• detune (0): величина расстройки

superreese

Vaguely Reese-like синтезатор:

• accelerate (0): плавное изменение высоты тона.
• voice (0): количество голосов.
• detune (0): величина расстройки.

supernoise

импульсный шум с плавным нарастанием/затуханием.

• voice: при значении 0 — цифровой шум, для которого «n» управляет частотой среза, при значении 1 — коричнево-белый шум, для которого «n» управляет частотой среза.
• accelerate: вызывает плавное увеличение частоты среза, «Скорость» — повторение.
• pitch1: масштабирует частоту полосы пропускания (которая отслеживает «n»).
• slide: работает как ускорение в полосе пропускания.
• resonance: резонанс фильтра.

supercomparator

• voice (0.5): масштабирует частоты компаратора, более высокие значения будут звучать «дышаще».
  
• decay (0)
• accelerate (0): плавное изменение высоты тона.
  resonance (0.5): резонанс фильтра.
• LFO (1): степень влияния LFO на частоту фильтра.
• rate (1): частота LFO.
• pitch1 (1): множитель масштабирования частоты фильтра, сама частота следует высоте тона, заданной параметром «n».

Физическое моделирование

supermandolin

физическое моделирование вибрирующей струны с использованием линии задержки (CombL), возбуждаемой начальным импульсом (Impulse). чтобы сделать звучание более насыщенным, объединили две слегка расстроенные линии задержки:

• sustain (1): изменяет временной масштаб огибающей
• accelerate (0): плавное изменение высоты тона
• detune (0.2): величина расстройки

superpiano

• velocity: влияет на силу нажатия клавиш;
• sustain: управляет огибающей и временем затухания;
• detune (0.1): величина расстройки.
• muffle (1);
• stereo (0.2): уровень стерео.

Voices are drawbar presets:

• 0. bass violin 16’
• 1. tibia 8’
• 2. bassoon 8’
• 3. french trumpet 8’
• 4. string ensemble
• 5. Blues
• 6. Jazz 1
• 7. Full Shout
• 8. Bro’ Jack
• 9. Jazz 2

supervibe

• decay (0): используйте большие значения для подавления высших гармоник.
• velocity (1): более высокая скорость немного оживит звук.
• accelerate (0): для линейного изменения высоты тона.
• modamp (1): амплитуда тремоло (0-2 подходит).
• modfreq (7): частота тремоло.
• detune (0): регулирует высшую гармонику, чтобы придать звуку другой характер.

все остальное можно увидеть здесь.

• Сигнатура типа: как функция объявлена ​​на стороне Haskell.
• Описание: словесное описание функции.
• Примеры: небольшой список примеров, которые можно скопировать и вставить в редактор.

Сэмплирование аудио

chop

функция chop разрезает каждый паттерн на заданное количество частей, позволяя изучить метод, известный как «гранулярный синтез». он преобразует паттерн образцов в паттерн частей образцов:

каждый сэмпл делится на 16 бит, что даёт 64 (16*4) события. можно задать паттерн для первого параметра:

в результате получается паттерн из нарезанных фрагментов сэмплов. это можно услышать это более отчётливо, например, перевернув паттерн, так как изменяется порядок частей сэмплов:

тут это происходит только с одним динамиком:

различные значения измельчения могут давать совершенно разные результаты в зависимости от используемых сэмплов:

также можете использовать функцию chop (или striate) для очень длинных сэмплов, чтобы разрезать их на короткие фрагменты и структурировать их. следующий код разрезает сэмпл на 32 части и воспроизводит его в течение 8 тактов:

функция loopAt изменяет скорость воспроизведения сэмпла, чтобы он идеально укладывался в заданное количество циклов. в результате в примере выше гранулы идеально выстраиваются в линию, поэтому не слышно, что сэмпл был нарезан на фрагменты. опять же, это становится более очевидным при дальнейших манипуляциях с паттерном, например, при использовании rev для изменения порядка нарезанных фрагментов:

striate

striate - это своего рода гранулятор, разрезающий образцы на каты подобно чопу, но полученные каты организованы иначе:

это воспроизводит цикл заданное количество раз, но запуская прогрессивные фрагменты каждого сэмпла. таким образом, в данном случае цикл воспроизводится три раза: в первый раз - первая треть каждого сэмпла, затем - вторая треть каждого сэмпла, и, наконец, - последняя треть каждого сэмпла. если сравнить это с это с функцией chop:

striateBy

striateBy (= striate') - это вариант striate с дополнительным параметром, который задаёт длину каждой части. striate по-прежнему сканирует сэмпл за один цикл, но если каждый бит длиннее, возникает своего рода эффект заикания. например, следующий код разрежет сэмпл bev на 32 части, но каждая будет иметь длину, равную 1/16 сэмпла:

важно, что striate использует внутренние параметры begin и end. это означает, что если используется striate или striateBy, не следует указывать также begin и end.

slice

функция slice похожа на функцию chop and striate, поскольку позволяет нарезать сэмплы на фрагменты. разница в том, что она позволяет переставлять эти фрагменты в виде pattern.

вышеприведенный код разрезает сэмпл на восемь бит, а затем воспроизводит их в обратном порядке, что эквивалентно применению rev $ chop 8. более сложный пример:

splice

splice похоже на нарезку, но нарезки автоматически наклоняются вверх или вниз, чтобы заполнить свой «слот».

randslice

randslice разрезает сэмпл на заданное количество частей, а затем воспроизводит случайную часть в каждом цикле:

можно юзать быстрый режим, чтобы получить больше одного за цикл;

chew

chew работает так же, как и bite, но ускоряет/замедляет воспроизведение звуков, а также сжимает/контрастит части паттерна:

loopAt

loopAt подгоняет сэмпл под заданное количество циклов. внутренне она работает следующим образом: устанавливает единицу управления на «c», изменяет скорость воспроизведения сэмпла с помощью параметра «speed» и устанавливает соответствующую плотность паттерна.

хорошей идеей является использование этой функции в сочетании с функцией chop, так разрыв будет по частям, и не придется ждать, пока начнется/остановится весь сэмпл.

как и со всеми функциями Tidal, с этой функцией можно экспериментировать. пример ниже показывает, как задать шаблон количества циклов для loopAt:

smash

smash - это комбинация spread и striate: он нарезает сэмплы на заданное количество битов, а затем вставляет их между воспроизведением цикла на разных скоростях в соответствии со значениями в списке.:

smash'

smash' - это smash, но основано но chop, а не striate.

до

=

vs

))

сэмплинг по сигналам

segment

segment «сэмплирует» паттерн с частотой n событий за цикл. полезно для преобразования непрерывного паттерна в дискретный. в этом примере паттерн формируется из формы синуса, непрерывного паттерна. без segment отсчёты будут запускаться с неопределённой частотой, которая может быть очень высокой.

sig

функция sig принимает функцию времени и преобразует её в шаблон. Это очень полезно для создания непрерывных паттерноа, таких как sine или perlin. saw определяется как:

• Сигнатура типа: как функция объявлена ​на стороне Haskell.
• Описание: словесное описание функции.
• Примеры: небольшой список примеров, которые можно скопировать и вставить в редактор.

Псевдорандомизация

rand

rand - это генератор, генерирующий последовательность (псевдо) случайных чисел с плавающей запятой в диапазоне от 0,0 до 1,0. например, для случайного панорамирования стереополя можно:

или, чтобы наслаждаться случайной скоростью от 0,5 до 1,5, вы можете прибавить к значению 0,5.

irand

функция irand похожа на rand, но генерирует непрерывный генератор (псевдо) случайных целых чисел от 0 до n-1 включительно. в частности, используется для выбора случайных сэмпла из папки.

Перлинов шум

perlin

perlin создаёт 1D Perlin (гладкий) шум. jн работает как rand, но плавно переключается между случайными значениями в каждом цикле. например, можно плавно и случайным образом изменять скорость:

функция perlin генерирует новое случайное значение для каждого цикла. если вы хотите, чтобы новое случайное значение генерировалось чаще или реже, используйте fast или slow соответственно:

perlinWith

perlinWith позволяет указать паттерн в качестве входных данных для генерации случайных значений вместо использования количества циклов по умолчанию:

perlin2

perlin2 создает 2D шум, позволяя указать пользовательский паттерн в качестве второго измерения (номер цикла остается первым измерением):

perlin2With

perlin2With - это то же самое, что и perlinWith, за исключением того, что он позволяет предоставить две функции для 2D шума:

"sometimes"

sometimes

sometimes это функция, которая применяет другую функцию к паттерну примерно в 50% случаев случайным образом. для неё требуются два входных параметра: функция, которую нужно применить, и паттерн, к которому вы её применяете.

например, чтобы исказить половину событий в шаблоне:

sometimes имеет несколько вариантов, которые применяют функцию с разной вероятностью:

sometimesBy

если вы хотите уточнить, вы можете использовать sometimesBy и число, например:

применять контроль скорости в среднем 93 раза из 100.

someCycles

функция someCycles похожа на sometimes, но вместо применения заданной функции к случайным событиям она применяет её к случайным циклам. например, следующий код либо исказит все события в цикле, либо ни одно из них:

someCyclesBy

как и в случае с sometimesBy, для конкретики можно использовать someCyclesBy и число. например:

будет применять контроль скорости в среднем в 93 циклах из 100.

Выбор случайным образом

choose

функция choose выдает поток случайно выбранных значений из заданного списка в виде непрерывного паттерна:

как и в случае со всеми непрерывными паттернами, следует позаботиться о том, чтобы придать им структуру; в этом случае choose дает бесконечно подробный поток случайных выборов.

chooseby

функция chooseBy похожа на choose, но вместо случайного выбора элементов списка она использует заданный паттерн для выбора элементов.

= паттерн "a b c".

wchoose

wchoose чем-то похожа на функцию choose, но позволяет «взвешивать» варианты, чтобы вероятность выбора некоторых вариантов была выше, чем вероятность выбора других. следующий пример похож на предыдущий, но вероятность выбора числа 2 в два раза выше, чем у чисел 0 или 3.

wchooseby

wchooseBy = wchoose, но вместо случайного выбора элементов списка она использует заданный шаблон для выбора элементов.

cycleChoose

= choose, но выбор производится только один раз за цикл:

markovPat

markovPat - это способ генерации (псевдо) случайных паттернов на основе Markov chains. Markov chain представляет собой не предопределённый паттерн, а предопределённую последовательность вероятностей. эти вероятности управляют переходами от одного шага к другому. что даёт прямой контроль над случайностью генерируемого шаблона. markovPat принимает три аргумента: длину последовательности, индекс начального шага и матрицу вероятностей.

сначала определите значения для каждого состояния. например, если вы хотите составить последовательность из трёх звуков: bd, sd и clap:

при таком сопоставлении «bd» имеет индекс 0, «sd» - индекс 1, а «clap» - индекс 2. Обратите внимание, что вы можете включать паузы, добавляя «~» в качестве одного из звуков.

затем определите вероятность того, что каждый шаг перейдёт в каждый другой шаг. обратите внимание: значения будут нормализованы, поэтому их сумма не обязательно должна равняться 1.

в приведенном выше примере вероятность повторения bd составит 10%, вероятность перехода в sd - 70%, а вероятность перехода в clap - 20%. если добавить это к шаблону с длиной последовательности 16 и начальным индексом 0:

как и другие источники случайности, ритмическую структуру можно добавлять с помощью таких функций, как mask.

зачем это нужно

предположим, мы хотим изменить сэмпл sax во время его воспроизведения, применяя различные значения эффекта squiz:

это не сработает. поскольку структура определяется sound "sax", за цикл происходит только одно событие, поэтому squiz всегда будет использовать первое значение (1).

что можно попробовать:

теперь структура взята из правой части, поэтому на цикл будет приходиться 4 события, каждое с разным значением squiz. но сэмпл будет срабатывать 4 раза с самого начала. мы хотим изменять squiz во время воспроизведения сэмпла, а не перезапускать его.

ещё идея юзать chop:

это разрезает сэмпл sax на четыре части и применяет к каждой из них одно из значений squiz. тк сэмпл длится не ровно один цикл, в точках разделения наблюдается заметное изменение звука, и он не плавный.

использование контроля звука для управления

теперь мы изменяем величину squiz во время воспроизведения сэмпла.

squizbus определяется следующим образом:

Ппервый параметр - это идентификатор управления. он должен быть уникальным, поэтому, если вы управляете двумя эффектами по отдельности, вам потребуется использовать разные номера:

эта идентификация должна быть уникальной для всех паттернов, если только вы не хотите, чтобы два подшаблона управлялись из одного источника. в этом случае, вероятно, один шаблон управления будет, например, lpfbus 2 "1000 5000", а другие будут только получать данные, например, hpfrecv 2:

здесь вы можете услышать, как фильтры нижних и верхних частот изменяются по мере воспроизведения сэмпла, но оба используют одни и те же значения.

hpfrecv определяется следующим образом:

вы даже можете создать шаблон этой идентификации:

большинство эффектов имеют функцию bus и recv, которые можно использовать таким образом.

возможность управления также можно использовать для создания LFO на эффектах:

в этих примерах мы используем segment для выборки значения sine и smooth, поскольку это непрерывные шаблоны и они не будут работать напрямую.

кроме того, вы можете подготовить паттерны для приема управляющих сигналов, а затем отправлять их из других паттернов:

Ограничения

не все параметры управления можно контролировать через управление. вот полный список параметров, управление которыми невозможно:

в этом списке есть note, n, gain и accelage, а вот amp - нет.

если вы попытаетесь использовать управление по одному из этих параметров, вы получите такое сообщение об ошибке:

panbus будет работать, но в диапазоне от -1 до 1 вместо 0 до 1:

контроль управления и MIDI

иожно сопоставить номера MIDI CC с контролем управления и использовать внешний MIDI-контроллер для изменения параметров в реальном времени.

в приведенном выше примере номер CC 21 сопоставлен с djf. cF указывает, что значение MIDI CC следует обрабатывать как число с плавающей точкой, а значение 0–127 из сигнала MIDI автоматически преобразуется в диапазон 0–1. Начальным значением по умолчанию является 0,5.

тут roombus 3 («^23») сопоставляет номер CC 23 с параметром room, не указывая никакого начального значения.

в некоторых случаях вам потребуется адаптировать диапазон значений CC по умолчанию:

значение параметра squiz не имеет диапазона от 0 до 1. для этого нам нужны значения, большие или равные 1.

в последнем примере диапазон 0-1 изменяется, и получается диапазон от 1 до 8, что является подходящими значениями для squiz.