07-grani.tidal

-- finora abbiamo lavorato con pattern di campioni. ma se dividiamo questi campioni in parti, possiamo lavorare con pattern di parti.

-- prendiamo un sample abbastanza lungo:

d1 $ sound "sax"

-- possiamo usare i controlli 'begin' ed 'end' per riprodurre solo una parte del campione:

d1
$ sound "sax"
# begin 0.1
# end 0.2

-- e se volessimo fare questo?

d1
$ sound "sax*4"
# begin "0 0.25 0.5 0.75"
# end "0.25 0.5 0.75 1"

-- c'è una funzione che realizza esattamente questo, di nome chop:

d1 $ chop 4 $ sound "sax"

-- così 'sax' è diviso in quattro parti, tagliate in maniera tale che appena ne finisce una, inizia quella immediatamente successiva. dunque a cosa ci serve?
-- be', possiamo applicare funzioni al pattern di parti:

d1 $ rev $ chop 8 $ sound "sax"

d1 $ iter 4 $ chop 8 $ sound "sax"

d1
$ stutWith 4 (1/4) (|* speed 1.5)
$ chop 8
$ sound "sax"

-- quando prendiamo un campione relativamente breve e lo frammentiamo in parti molto piccole, riordinare questi frammenti diventa una tecnica di sintesi, nota come *sintesi granulare*.

d1
$ stutWith 8 (1/12) (|* gain 0.98)
$ jux rev
$ iter 4
$ chop 40
$ sound "cp"

-- possiamo anche choppare campioni più lunghi, ovviamente. ma prima, un'avvertenza.
-- Tidal non presta attenzione a quanto siano lunghi i campioni, o a quale sia il loro contenuto. questo significa che, nel riprodurli ciclicamente, campioni ritmici (eg breakbeat) possono sovrapporsi tra loro in maniera sconveniente:

d1 $ sound "breaks152"

-- una funzione che risolve questo problema è loopAt:

d1 $ loopAt 2 $ sound "breaks152"

-- indipendentemente dal tempo globale, il campione è accelerato o rallentato così da occupare 2 cicli.
-- se combiniamo loopAt con chop, otteniamo parti di campione correttamente allineate.

d1 $ loopAt 2 $ chop 8 $ sound "breaks152"

-- jungle!

d1 $ jux (rev) $ iter 4 $ loopAt 2 $ chop 8 $ sound "breaks152"

-- c'è anche un'altra funzione, splice, che permette di patternare l'ordine dei grani:

d1 $ loopAt 2 $ slice 8 "1 2 4 3 6 5 7 8" $ sound "breaks152"

d1 $ loopAt 2 $ slice 8 "8 1 4 3*2 6 5*3 [7 6] 8" $ sound "breaks152"

d1 $ loopAt 2 $ slice 8 (iter 4 $ "1 2 3 4 5 6 7 8") $ sound "breaks152"