From 94ac7595aa251bbc3c5e6122a5050942facca975 Mon Sep 17 00:00:00 2001 From: Paul-Louis NECH Date: Fri, 8 May 2020 22:45:43 +0200 Subject: [PATCH] update: study --- live/chill/atm/board.tidal | 37 +++++++++++++++++++++++++++++++++++++ live/chill/atm/workroll.tidal | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ live/chill/blue_mind.tidal | 48 ++++++++++++++++++++++++++++-------------------- live/dnb/nass.tidal | 7 ++++--- live/dnb/vendredi_dnb.tidal | 31 ++++++++++++++----------------- live/dnb/video_live.tidal | 149 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ live/fusion/you_may.tidal | 13 ++++++------- live/techno/exutoire.tidal | 94 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ output/FleursVagues.jpg | Bin 0 -> 136846 bytes output/Flower_poster_2.jpg | Bin 0 -> 4487679 bytes study/club/14april.tidal | 27 ++++++++++++++++----------- study/club/course.md | 6 ++++++ study/club/melodic.tidal | 3 +++ study/club/w1.tidal | 30 ++++++++++++++++++++++++++++++ study/club/w2.tidal | 299 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ study/club/w3.tidal | 232 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ study/slicing.tidal | 12 ++++++++++++ 17 files changed, 979 insertions(+), 58 deletions(-) create mode 100644 live/chill/atm/board.tidal create mode 100644 live/chill/atm/workroll.tidal create mode 100644 live/dnb/video_live.tidal create mode 100644 live/techno/exutoire.tidal create mode 100644 output/FleursVagues.jpg create mode 100644 output/Flower_poster_2.jpg create mode 100644 study/club/course.md create mode 100644 study/club/melodic.tidal create mode 100644 study/club/w1.tidal create mode 100644 study/club/w2.tidal create mode 100644 study/club/w3.tidal create mode 100644 study/slicing.tidal diff --git a/live/chill/atm/board.tidal b/live/chill/atm/board.tidal new file mode 100644 index 0000000..db7e678 --- /dev/null +++ b/live/chill/atm/board.tidal @@ -0,0 +1,37 @@ +setcps 0.25 + +d1 +$ every' 8 7 (fast 2) +$ "k . k(<3 5>, 8)" # "kick:8" +# lpf 2000 +# gain 0.7 + +d2 $ "~ s" # "snare:2" +# lpf 5000 # note (-8) +# gain 0.7 + +d3 +$ fast 2 +$ fast "<8!3 32> <16!3 [16 <8 [8 16]>]>" +$ s "drum:8" +# gain 0.9 + +d4 $ s "h*3 h h*2" # "hh" # gain 0.8 +# pan (slow 16 $ sine) + +d4 +$ whenmod 32 16 (slow 2) +$ swing 2 +$ note (scale "aeolian" +"c3'major7" + "0 . 1 <2 0>" +) # s "supersaw" +# voice 0.1 +# gain 0.45 + +d5 +$ note ( + "0(12?,8)" +) # s "superpiano" +# velocity 0.35 +# pan 0.8 +# sustain 0.4 diff --git a/live/chill/atm/workroll.tidal b/live/chill/atm/workroll.tidal new file mode 100644 index 0000000..5525ec3 --- /dev/null +++ b/live/chill/atm/workroll.tidal @@ -0,0 +1,49 @@ +setcps 0.5 +-- 2s / mesure +-- MicroPomodoro = 5m = 5*60 = 20 * 15 = 300 secondes = 150 mesures +-- Pomodoro = 25m = 25*60 = 100 * 15 = 1500 secondes = 750 mesures + +d1 +$ every' 2 1 (often (off 0.125 id)) +$ whenmod 750 375 (fast 2) +$ whenmod 150 140 (# silence) +$ whenmod 150 75 (fast 2) +$ s "reverbkick" # lpf 400 + +d2 +$ almostNever (fast 4) +$ s "~ snare:11" + +d3 +$ whenmod 150 140 (# room 0.5) . (# dry "<0 0.5 1 2>") +$ whenmod 150 130 (fast "8 . 2 4") +$ whenmod 24 20 (fast 2) +$ fast "<8 4 8 1>" $ s "drum:8" + +d4 -- Bass tendue/detendue +$ whenmod 150 0 (off 0.125 (# crush 8)) +$ sometimesBy "<0.5 0> 0" (chop "<4 2>") +$ note (scale "aeolian" ( + "0(3,<4 8>)" + "<0 2 0 5 0 4 0 5>" +) +- 24 +) +# s "supersaw" # voice 0.1 +# sustain 0.5 +# gain 0.9 + +d3 -- bass +$ note ("<<0 3> <0 3> <0 -4> <0 -4>>" + +"0 7 ~ 0 6 7 6 3") +# s "bass3" +# gain 0.8 + +d6 $ s "birds/4" # n (irand 16) +# speed (range 0.5 2 rand) +# gain 0.7 + +d9 -- Period end siren +$ whenmod 150 130 (# gain 0.8) +$ s "supersiren/16" +# note (-12) +# gain 0 diff --git a/live/chill/blue_mind.tidal b/live/chill/blue_mind.tidal index 548bc70..40699ed 100644 --- a/live/chill/blue_mind.tidal +++ b/live/chill/blue_mind.tidal @@ -1,28 +1,46 @@ setcps 0.4 do + solo 1 -- Kick + solo 2 -- Snares + solo 3 -- Drums + solo 4 -- + solo 5 + solo 6 + unsolo 7 + +do d1 -- KICK TECHNOFICATION $ sometimesBy "0 0 0.1 0" (# silence) -- skip beat - $ s "k*4" + $ s "k*2" # s "jazz" - # gain 0.8 + # gain 0.7 d2 - -- $ sometimes (fast 2) - -- $ whenmod 16 8 (sometimes (stut 2 0.7 (1/12))) + $ whenmod 16 8 (sometimes (stut 2 0.7 (1/12))) $ n "0(1,8,<1 .. 7>)" # s "snare:13" # gain 0.6 d3 -- $ rarely (fast 2) - -- $ sometimes (fast 2) - -- $ always (fast 2) + $ sometimes (fast 2) + $ always (fast 2) $ s "d*4" # s "drum:8" - # gain 0.9 - d4 $ s "hh*4" # gain 0.6 + # gain 0.8 + d4 $ s "hh(6,16)" # gain 0.9 # n "<0!3 [0!3 1]>" -- Pianos -- Graves accords sustain - d5 + d5 -- Basse + $ s "supersaw" + # note (scale "aeolian" ( + "" + + "<<0!3 -1> 0 0 <2!3 1>>" + ) - 24 + ) + # voice 0.1 + # gain 0.4 + d7 -- Cloches + $ off 0.25 (|+ note "<12 0>") $ off 0.125 (|+ note 12) $ note (scale "aeolian" ( "" @@ -30,7 +48,7 @@ do ) - 24 ) # s "superfork" - # gain 0.7 + # gain 0.6 d6 $ whenmod 64 32 (superimpose (-- Arps! whenmod 128 64 (swing 2) @@ -49,16 +67,6 @@ do # s "supersaw" # velocity 0.3 # gain 0 - d7 -- Basse - $ s "supersaw" - # note (scale "aeolian" ( - "" - + "<<0!3 -1> 0 0 <2!3 1>>" - ) - 24 - ) - # voice 0.1 - # gain 0.4 - -- Setup: solennel, hip, calme diff --git a/live/dnb/nass.tidal b/live/dnb/nass.tidal index 31bccfd..127fb47 100644 --- a/live/dnb/nass.tidal +++ b/live/dnb/nass.tidal @@ -12,13 +12,14 @@ setcps 0.65 -- DNB d1 $ fix ( - (# s "[nass,cp]") . + -- nass + (# s "[nass,sn:1]") . (someCyclesBy 0.1 (# attack 0.5)) -- cut, presque scratch ) (s "t") -$ fix (# s "[kick:8,kick:9]") (s "p") +$ fix (# s "kick:8") (s "p") -- $ s "bd ~ s ~ ~ bd s <~ s>" $ s "p ~ t <~ t ~ ~> ~ p t <~ p>" -# gain 0.9 +-- # gain 0.9 d2 -- bass diff --git a/live/dnb/vendredi_dnb.tidal b/live/dnb/vendredi_dnb.tidal index 33b9f9e..356dbd5 100644 --- a/live/dnb/vendredi_dnb.tidal +++ b/live/dnb/vendredi_dnb.tidal @@ -1,5 +1,6 @@ -- Base: DNB Dansante! -setcps 0.75 +setcps 0.6 + d1 -- Poum tchak $ whenmod 8 4 (someCycles (fast "1 2")) @@ -10,28 +11,20 @@ $ fix (# s "[bskick,kicklinn]") (s "b") $ s "b? ~ s ~ ~ b s <~ <~ <~ s>>>" d3 -- drumroll -$ rarely (off (1/16) id) -$ sometimesBy 0.05 (# n 1) -$ s "dr*8" -# room (slow 16 $ sine * 0.3) -# size 0.2 -# gain (slow 32 $ sine * 0.9 + 0.1) - -d5 $ s "brass:6" # note 0 -# gain 0.85 +$ fast "4 <8 16>" $ s "drum:2" # gain 0.9 d6 $ whenmod 32 24 ( -- final trompette! - superimpose (const $ s "~ ~ ~" - # s "brass:6" # gain 0.95) + superimpose (const $ slow 2 $ s "~ ~ ~" + # s "brass:6" # gain 0.6) ) $ whenmod 8 4 (degradeBy 0.5) $ superimpose (|+ note 12) $ superimpose (|- note 12) -$ s "brass:2" +$ s "brass:2/2" # note "<0 0 0 <<12 5> 0>>" +# gain 0.5 # cut 1 -# gain 0.85 d7 -- toys $ every' 16 15 ( -- petit coup @@ -39,7 +32,12 @@ $ every' 16 15 ( -- petit coup $ every 16 ( -- intense! sometimes (superimpose (const $ s "~ ~ brass:10 ~"))) $ s "~ brass:7/4 ~ brass:5/8" -# gain 0.8 +# gain 0.45 + +d4 + $ note (scale "aeolian" "<0 5>(<3 5>,8)" + -24 + ) # s "supersaw" # voice 0.1 # gain 0.8 d9 -- basse $ stut 4 0.75 0.125 @@ -48,8 +46,7 @@ $ (|+ note (scale "major" "7")) $ whenmod 8 4 (|+ note (scale "major" "5")) $ off 0.125 ((# room 0.2) . (# size 0.8)) -- $ superimpose ((# s "bass3") . (|+ note 0)) -$ note "0" -|- note 14 +$ note (-36) # gain 0.9 # attack (0.5 + rand / 2) # s "bassWarsaw" diff --git a/live/dnb/video_live.tidal b/live/dnb/video_live.tidal new file mode 100644 index 0000000..0d56136 --- /dev/null +++ b/live/dnb/video_live.tidal @@ -0,0 +1,149 @@ +do + solo 1 + solo 2 + solo 4 + solo 7 -- bass + s + +d1 +$ fast "1" +$ s "jazz(<4!3 <2 [2 4]>>,8)" +# gain 0.8 + + +d1 $ s "k(<3!3 4 5 4>,8)" # s "clubkick" +# gain 0.8 +# lpf (slow 16 $ range 4000 20000 sine) + +d2 +$ hurry "<1 [1|2]>" +$ s "~ " +# s "snare:20" +# gain 0.9 + +d3 +$ whenmod 32 4 (# gain 0.9) +$ whenmod 32 0 (# gain 0) +$ fast "4 [8 <1?*16 16>]" $ s "dr" +# gain 0.9 + +d5 +$ whenmod 32 31 (# gain "0!3 0.7") +$ whenmod 32 16 (# gain "0") +$ whenmod 16 8 rev +$ bite 8 +-- "0 <1 2> <2 1> 3*2" +"<0 <1 2> <2 1>>(<8!7 5>,8)" +$ note (scale "aeolian" (run 8) +- 24) +# s "supersaw" # voice 0.1 +# gain 0.75 + +d6 -- Piano second TODO REWORK +-- $ every 4 (# gain 1) +$ (0.5 ~>) +$ stut' 2 0.25 (|+ note "~ . <0 +7>") +$ sometimesBy "0 0.5" (ply 2) . (arp "~ . up down") +$ note ("*2") +# s "superpiano" +# velocity "0.5 0.4" +# sustain 0.8 +# gain 0 + +d8 -- Cymbales +$ juxBy 0.5 rev +$ fast 2 +$ s "h ~ h h ~ ~ ~" # s "hh" +# gain 0.6 + + +d7 -- Basse lead :) + $ whenmod 16 20 (|> note "-12") + $ whenmod 20 10 (degrade . (stut 2 0.9 0.125)) + $ note (scale "aeolian" "<0 5>(<3 5 8>,8)" + - (slow 8 $ "<24 12>") + ) # s "supersaw" # voice 0.1 + # gain (slow 16 $ range 0.5 0.7 saw) + +d4 + $ note (scale "aeolian" "<0 5>(<3 5>,8)" + - 36 + ) # s "superfork" # accelerate 0.1 + # gain 1 + +-- outru + +do + solo 1 + solo 2 + solo 4 + solo 7 -- bass + s + +d1 +$ fast "1" +$ s "jazz(<4!3 <2 [2 4]>>,8)" +# gain 0.8 + + +d1 +$ slow 2 +$ s "k(<3!3 4 5 4>,8)" # s "clubkick" +# gain 0.6 +# lpf (slow 16 $ range 4000 20000 sine) + +d2 +$ hurry "<1 [1|2]>" +$ s "~ " +# s "snare:20" +# gain 0.9 + +d3 +$ whenmod 32 4 (# gain 0.9) +$ whenmod 32 0 (# gain 0) +$ fast "4 [8 <1?*16 16>]" $ s "dr" +# gain 0.9 + +d5 +$ whenmod 32 31 (# gain "0!3 0.7") +$ whenmod 32 16 (# gain "0") +$ whenmod 16 8 rev +$ bite 8 +-- "0 <1 2> <2 1> 3*2" +"<0 <1 2> <2 1>>(<8!7 5>,8)" +$ note (scale "aeolian" (run 8) +- 24) +# s "supersaw" # voice 0.1 +# gain 0.75 + +d6 -- Piano second TODO REWORK +-- $ every 4 (# gain 1) +$ (0.5 ~>) +$ stut' 2 0.25 (|+ note "~ . <0 +7>") +$ sometimesBy "0 0.5" (ply 2) . (arp "~ . up down") +$ note ("*2") +# s "superpiano" +# velocity "0.5 0.4" +# sustain 0.8 +# gain 0 + +d8 -- Cymbales +$ juxBy 0.5 rev +$ fast 2 +$ s "h ~ h h ~ ~ ~" # s "hh" +# gain 0.6 + + +d7 -- Basse lead :) + $ whenmod 16 20 (|> note "-12") + $ whenmod 20 10 (degrade . (stut 2 0.9 0.125)) + $ note (scale "aeolian" "<0 5>(<3 5 8>,8)" + - (slow 8 $ "<24 12>") + ) # s "supersaw" # voice 0.1 + # gain (slow 16 $ range 0.5 0.7 saw) + +d4 + $ note (scale "aeolian" "<0 5>(<3 5>,8)" + - 36 + ) # s "superfork" # accelerate 0.1 + # gain 1 diff --git a/live/fusion/you_may.tidal b/live/fusion/you_may.tidal index d99ae96..31a33bb 100644 --- a/live/fusion/you_may.tidal +++ b/live/fusion/you_may.tidal @@ -3,21 +3,20 @@ do solo 1 solo 2 - unsolo 3 - unsolo 4 - unsolo 5 - unsolo 6 + solo 3 + solo 4 + solo 5 + solo 6 solo 7 solo 8 - do let cLaMin = "[4, 7, 12, 14]" let cReMin = "[2, 4, 8, 11]" -- le fameux sol dièse ! let cMiMaj = "[2, 5, 7, 10]" - setcps 0.45 - d1 + setcps 0.45 -- rythme + d1 -- Kick grosse caisse $ jux rev $ whenmod 8 6 (fast 2) $ fast 2 diff --git a/live/techno/exutoire.tidal b/live/techno/exutoire.tidal new file mode 100644 index 0000000..e6e2c65 --- /dev/null +++ b/live/techno/exutoire.tidal @@ -0,0 +1,94 @@ +--T0: Hip-hop chill exutoire + +do + d1 $ s " . <~ k?>" # "reverbkick" # release 0.3 # gain 0.8 + d2 $ hurry 0.5 $ degradeBy "<0 0 0.5>" $ s "~ s*<1 3 6>" # "sn:1" # gain 0.8 # hpf 500 + d3 $ fast ("<4!3 [<4 12> 12]>") $ s "dr" # gain 0.5 + d4 + $ chop 2 + $ note (scale "hexAeolian" "0 0*2 ~ <4!3 6> . <2 5 2 4>" + - 21 + ) # s "supersaw" # voice 0.1 + # gain 0.7 + + d5 $ silence + $ fast "1 . 1 <1!8 2!4 3!4>" + $ note (scale "hexAeolian" "0*2 ~ ~. <-1 2>" + + "" -- progression accords + + (slow 8 $ "<12 0>") -- variations octave + ) # s "superpiano" + # velocity "0.5 0.4 ~ ~ . 0.5" + # sustain 1 + # gain 0.6 + +-- T1: Raté ! techno + +do + let bars4 = 128 + let bars2 = 64 + let bars = 32 + let b2Mid = 48 + let bMid = 16 + let gKick = 0.8 + d1 -- KICK! Sait se faire attendre + $ whenmod bars (bMid + 1) (# gain 0) + $ whenmod bars bMid (# gain ("1 0!3" * gKick)) + $ s "k k < [k|~k]> " # "clubkick" + # gain 0.75 + # lpf 1500 + # pan (slow 8 $ range 0.5 0.4 sine) + # gain 0.8 + d2 -- Snares ternaires hurried, finissant en rush carré + $ juxBy 0.6 rev + $ whenmod bars (bars + 999) (const + $ degradeBy (slow 2 $ "<0.5 0.25 0.125 0>") -- avance masqué + $ fast "<4 8 16 [8 16 24 32]>" -- snare rush classique + $ s "sn:1" # gain 0.8 # hpf 500 + ) + $ every' bars 0 (# gain 0) + $ hurry "0.5 [1|2]" $ degradeBy "<0 0 0.5>" + $ s "~ s*<1 3 6>" + # "sn:1" + # gain 0.8 + # hpf 500 + # pan 0.3 + d3 -- Drumroll ternaire + $ fast ("<4!3 [<4 12> 12]>") $ s "dr" + # gain (slow 32 $ range 0.7 0.9 sine) + d4 + $ whenmod bars2 b2Mid (chop 2) + $ note (scale "hexAeolian" + ( + whenmod bars4 bars2 (0 -) + "0 0*2 ~ <4!3 6> . <2 5 2 4>" + |+| "<[0|2] [0 <0 2> 0] 0 [12|0]>") + - 24 + ) # s "supersaw" # voice 0.1 + # gain (slow 64 $ range 0.4 0.6 saw) + # pan 0.4 + d8 -- Claps au pont + $ whenmod bars (bMid + 4) (# gain (slow (bMid - 4) $ range 0.5 1 saw)) + $ s "~ c*<1 2>" # s "cp" # gain 0 + # pan (range 0.25 0.75 rand) + d9 -- Choeurs nappes secondaires + $ whenmod bars4 bars2 (# gain 0.5) + $ superimpose ((mask "t f!8") + . (# sustain 2) + . (|- note (slow 4 $ "<12 15 19 10>"))) + $ note (scale "hexAeolian" + ( + "[0 0*2 ~ <4!3 6> . <2>]" + 7 + |+| "<[0|2] [0 <0 2> 0] 0 [-12|0]>") + ) # s "moogBass" + # gain 0 + # pan 0.8 + + d5 $ silence + $ fast "1 . 1 <1!8 2!4 3!4>" + $ note (scale "hexAeolian" "0*2 ~ ~. <-1 2>" + + "" -- progression accords + + (slow 8 $ "<12 0>") -- variations octave + ) # s "superpiano" + # velocity "0.5 0.4 ~ ~ . 0.5" + # sustain 1 + # gain 0.6 diff --git a/output/FleursVagues.jpg b/output/FleursVagues.jpg new file mode 100644 index 0000000..ddfc5fb Binary files /dev/null and b/output/FleursVagues.jpg differ diff --git a/output/Flower_poster_2.jpg b/output/Flower_poster_2.jpg new file mode 100644 index 0000000..6314127 Binary files /dev/null and b/output/Flower_poster_2.jpg differ diff --git a/study/club/14april.tidal b/study/club/14april.tidal index d39a673..0f2b7d0 100644 --- a/study/club/14april.tidal +++ b/study/club/14april.tidal @@ -7,7 +7,7 @@ do leftHand = "[0 9 12 16] [4 12 16 19] . [5 12 17 19] [2 12 17 16]" cutPreEnd = "1!4 1 <1!7 0> <1!3 0> 0" cutPostBegin = "[0 <1!3 0>] 1!7" - d1 -- Piano, with cutting progression + d6 -- Piano, with cutting progression $ slow bars $ degradeBy (slowcat [ "1", @@ -23,19 +23,24 @@ do n (leftHand + key) ] # "superpiano" - # velocity 0.35 + # velocity 0.5 # octave "3" # sustain "[2 0.7]*4" - d2 -- Beat slowly varying - $ slow (bars / (slow 16 $ "<1 2>")) - $ s "d(<[5 4] [3 8] 5 [4 16]>,8)" - # s "jazz" - # lpf (slow 16 $ range 500 15000 sine) + d1 -- Beat slowly varying + $ s "k(<3!3 5>,8,<0!4 3!3 0>)" + # s "kick:5" + # hpf (slow 16 $ range 50 150 sine) + # gain 0.6 + d2 + $ whenmod 8 6 (hurry 2) + $ whenmod 8 4 (often (stut 4 0.8 (1/16))) + $ s "~ . ~" + # "snare:20" # gain 0.8 d3 -- Drumroll - $ fast "16 <2!3 8> <4!3 8> <1!3 <4, 8>>" + $ fast "<<4!3 <16 32>> [16 <16 8>]>" $ s "drum:2" - # gain (slow 8 $ range 0.65 0.8 sine) + # gain (slow 8 $ range 0.8 1 sine) d4 -- Bass $ slow bars $ rarely rev @@ -45,9 +50,9 @@ do $ note (leftHand + key) |- note 36 # s "bassWarsaw" - # gain 0.7 + # gain 0.9 d5 -- Choir - $ whenmod 4 2 (superimpose (|+ note 12) . (|- gain 0.1)) + $ whenmod 4 2 (|+ note 12) $ slow (bars * 2) $ bite 4 "0" $ note (leftHand + key) diff --git a/study/club/course.md b/study/club/course.md new file mode 100644 index 0000000..04d2008 --- /dev/null +++ b/study/club/course.md @@ -0,0 +1,6 @@ +# Program + +- [x] Week 1 +- [ ] Week 2 : L3 +- [ ] Week 3 +- [ ] Week 4 diff --git a/study/club/melodic.tidal b/study/club/melodic.tidal new file mode 100644 index 0000000..df2718c --- /dev/null +++ b/study/club/melodic.tidal @@ -0,0 +1,3 @@ +--TODO: Explore https://club.tidalcycles.org/t/melodic-examples-with-tidal/490/7 + +d1 $ stut' 3 (1/12) (|+ note "<5 3 0 7>") $ s "superpiano" diff --git a/study/club/w1.tidal b/study/club/w1.tidal new file mode 100644 index 0000000..090bfd9 --- /dev/null +++ b/study/club/w1.tidal @@ -0,0 +1,30 @@ +-- REVISION TASKS + +-- Copy each of the following patterns in turn, and edit them so that they +-- are shorter, using the "<>", "!", "[]" and/or "." introduced above. + +d1 $ sound "kick snare snare" +d1 $ sound "kick snare!2" + +d1 $ sound "kick [snare snare]" +d1 $ sound "kick snare*2" + +d1 $ sound "kick snare kick snare kick snare" +d1 $ sound "[kick snare]*3" + +d1 $ n "0 [1 2 3]/3" # sound "cpu2" +d1 $ n "0 {1 2 3}" # sound "cpu2" + +d1 $ n "[0 0 2] [4 5 6 7] [4 1] [0 3 0 3]" # sound "cpu2" +-- TODO: Final exercises + +d1 $ sound "kick snare kick snare kick snare clap" + +d1 $ sound "[kick snare kick snare kick snare] clap" +d1 $ sound "[kick snare]*3 clap" + +d1 $ sound "bd sd sd sd bd [sd sd sd]" + + +-- Lesson 5 +d1 $ sound "clap(3,5,2)" diff --git a/study/club/w2.tidal b/study/club/w2.tidal new file mode 100644 index 0000000..9cf5004 --- /dev/null +++ b/study/club/w2.tidal @@ -0,0 +1,299 @@ +-- region Lesson 1: starting with effects + +-- Tidal has lots of effects we can use to change the way things sound. + +-- vowel is a filter which adds a vowel sound +-- try a, e, i, o and u + +d1 $ n "0 1 0 [2 4] 2 4 1*2 3" # s "cpu" + +d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a" + +d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "o" + +-- We can use the mini notation to create sequences of effects too: + +d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a o e" + +-- Tidal does its best to map patterns across to one another. + +-- You can add a non-vowel letter to pause the vowel effect + +d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # vowel "a p" + +-- 'squiz' is a nice distortion effect +d1 $ n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" # squiz "4 1 0 3" + +-- With '#' structure comes from the left - try swapping the parameters around + +d1 $ squiz "4 1 0 3" # n "0 1 0 [2 4] 2 ~ 1*2 3" # s "cpu" + +-- Now there are only four sounds per cycle, because there's four in the leftmost +-- 'squiz' pattern + +-- We'll learn more about how things in patterns get matched up later! + +-- 'gain' changes the volume of different sounds + +d1 $ sound "kick kick snare snare" # gain "1 0.7 0.6 0.5" + +d1 $ sound "[hh*16, kick:8 snare:4 [~ kick:8] snare]" # gain "[1 1.2]*8" + +-- speed can be used to pitch samples +-- (we can also use 'note' to do this, but we'll look at that later) + +-- speed changes the speed of playback, +-- e.g. 2 = play the sample twice as fast - which moves the note up an octave + +d1 $ sound "numbers:1 numbers:2 numbers:3 numbers:4" # speed "1 1.5 2 0.5" + +-- Or we can take the pattern from the speed parameter + +d1 $ speed "1*2 2*2 4*6" # sound "jungbass:6" + +-- pan allows us to create stereo effects - 0 = left, 0.5 = middle, 1 = right + +d1 $ sound "numbers:1 numbers:2 numbers:3 numbers:4" # pan "0 0.5 1" + +-- shape adds distortion (but be careful - it also makes the sound much louder) + +d1 $ sound "kurt:4 kurt:4" + +d1 $ sound "kurt:4(3,8)" # shape "0 0.98" # gain "0.7" + +-- endregion + +-- region Lesson 2 : Time to look at Time + +-- "Music is the Time of Numbers" + +-- setcps - change global tempo + +-- Let's run two patterns at once: +d1 $ n "0 2 [3 5] [4 7]" # sound "cpu" + +d2 $ n "0(3,8) 8*8" # sound "cpu2" + # squiz 5 + +-- Changing the cps (cycles per second) changes everything +setcps 0.7 + +setcps 0.3 + +-- Time as an effexct (!) + +-- You can also set cps as an effect: +d2 $ n "0(3,8) 8*8" # sound "cpu2" + # squiz 5 + # cps 0.5 + +-- It's still global though - setting it on one pattern will +-- change it everywhere + +-- However, you can pattern it: +d2 $ n "0(3,8) 8*8" # sound "cpu2" + # squiz 5 + # cps "0.5 1" + +-- You can really mess with time in this way! +d2 $ n "0 [~ 1] 2*2 3 4*3 5 ~ 7" # sound "cpu2" + # cps "<0.5 2> [1 0.75] <2 1>" + +-- Reset things before moving on.. +hush + +setcps 0.6 + +-- 'fast' and 'slow' functions + +-- You can speed up / slow down an individual +-- pattern (or part of one) with "fast" and "slow" + + +d1 $ slow 2 $ n "0 2 [3 5] [4 7]" # sound "cpu" + +d1 $ fast 2 $ n "0 2 [3 5] [4 7]" # sound "cpu" + +-- You can also pattern this speed factor: +d1 $ slow "0.5 1" $ n "0 2 [3 5] [4 7]" # sound "cpu" + +d1 $ slow "0.5 <1 2>" $ n "0 2 [3 5] [4 7]" # sound "cpu" + +-- When patterning time in this way, you're switching +-- between different versions of the pattern, running +-- at different speeds. + +-- We've already learned enough to create patterns with a +-- lot of variety in them, by mixing together several simple +-- manipulations +d1 $ slow "0.5 <1 2>" $ + n "{0 2 [3 5] [4 <7 6>], 0*2 3*3 0}" # sound "cpu" + # squiz "<8 1 2>" + +-- Note that the 'speed' effect changes the rate of playback +-- for each sample, but doesn't change the overall speed of the +-- pattern +d1 $ slow "0.5 <1 2>" $ + n "{0 2 [3 5] [4 <7 6>], 0*2 3*3 0}" # sound "cpu" + # squiz "<8 1 2>" + # speed 2 + +-- I find things always sound better if you speed them up a little. +-- Your experience may vary :) +setcps 0.7 + +-- endregion + +-- region Lesson 3 Combining patterns with arithmetic, plus the ‘hurry’ function + +-- Ok, so what happens when we specify a 'control' pattern (like e.g. n, +-- sound, speed, or squiz) more than once? + +-- Lets start with the handy 'numbers' sounds: +d1 $ n "0 1 ~ 2" # sound "numbers" + +-- lets put than 'n' again, but with a different number: +d1 $ n "0 1 ~ 2" # sound "numbers" # n "4" + +-- So.. you can hear that we still have the rhythmic structure from +-- the left, but all the values have been replaced with the one on the +-- right. That's what `#` does! + +-- lets make that right hand pattern more complicated: +d1 $ n "0 1 ~ 2" # sound "numbers" # n "4 5" + +-- Now the 0 and 1 have been replaced with the 4, and the 2 has been +-- replace with the 5. + +-- This is because tidal matches them up for you, based on where they +-- are in the cycle. The 0 and 1 start inside the first half, so are +-- replaced with '4'. The 2 starts inside the second half, so is +-- replace by '5'. + +-- # is actually shorthand, for '|>'. There's a whole family of these: + +-- |> is structure from the left, values from the right +-- <| is values from the left, structure from the right +-- |< is structure from the left, values from the left +-- >| is structure from the right, values from the right +-- |<| is values from the right, structure from both sides +-- |>| is values from the left, structure from both sides + +-- < points to where the values come from, and | goes on the side where the +-- rhythmic structure comes from. + +-- Everything from the left: +d1 $ n "0 1 2 3" # sound "numbers" |< n "4 5" + +-- Everything from the right: +d1 $ n "0 1 2 3" # sound "numbers" >| n "4 5" + +-- Rhythmic structure from left, values from the right: +d1 $ n "0 1 2 3" # sound "numbers" |> n "4 5" + +-- Values from the left, rhythmic structure from right: +d1 $ n "0 1 2 3" # sound "numbers" <| n "4 5" + +-- Values from the left, rhythmic structure from both sides: +d1 $ n "0 1 2 3" # sound "numbers" |<| n "4 5" + +-- The above use of |<| sounds the same as |<, because the rhythmic +-- structures line up. + +-- This changes +d1 $ n "0 1 2" # sound "numbers" |>| n "4 5" + +-- Some gotchas! + +-- Even though you are taking everything from one side, something +-- still has to match up on the other side.. +-- So this makes no sound: +d1 $ n "~" # sound "numbers" >| n "4 5" + +-- Only the '4' sounds here: +d1 $ n "0 ~" # sound "numbers" >| n "4 5" + +-- Most of the time you'll be fine forgetting all this, and just using +-- |> , and its alias # . + +-- However, there are other things you can do! + +-- Instead of taking values from one side, you can add the values together, by +-- using '+' instead of '>' or '<'. + +-- This: +d1 $ n "0 1 2 3" # sound "numbers" |+ n "4 5" + +-- adds up to: +d1 $ n "4 5 7 8" # sound "numbers" + +-- This: +d1 $ n "0 1 2 3" # sound "numbers" +| n "4 5" + +-- adds up to: +d1 $ n "4 7" # sound "numbers" + +-- This is because the rhythm comes from the left, from the "4 5", and +-- so we start from that. The start of 4 matches with 0, and the start +-- of 5 matches with 2, and adding them up, we end up with 4+0=4, and +-- 5+2 = 7. + +-- This all gets complicated, especially when you work with patterns +-- with different numbers of steps.. + +d1 $ n "0 1 2 3" # sound "numbers" |+ n "4 5 6" + +-- But don't worry too much. You just have to say what you want to +-- add together, let Tidal worry about working it out for you! + +-- Ok that's enough numbers, lets put this into action with some +-- interesting patterns. + +-- Here's one adding together 'n' patterns, using |+| to take +-- structure from both sides. On the right hand side, it uses the < > +-- mininotation syntax to pick a different subsequence per cycle. +-- The result is an interesting, longer form pattern: + +d1 $ n "0 1 2 [3 5]" # sound "cpu" + |+| n "<[4 5 3 2] [5 4 3] [6 5]>" + # squiz 2 + +-- I just added a bit of squiz there to make it sound nice. + +-- Here's a simpler example, cycling between three 12 note octaves, one per cycle: +d1 $ n "7 5 [2 7] 0" # sound "superpiano" + |+ n "<-12 0 12>" + +-- It's actually possible to apply these to patterns of numbers +-- _before_ they become control patterns, like this: +d1 $ n ("7 5 [2 7] 0" |+ "<-12 0 12>") # sound "superpiano" + +-- You have to use parenthesis to make sure the two patterns are added +-- together, before being passed to the 'n'. + +-- To be clear, this is a pattern of numbers: +-- "7 5 [2 7] 0" + +-- This is a control pattern, because 'n' turns numbers into synthesiser +-- control patterns: +-- n "7 5 [2 7] 0" + +-- This all works for effects too: +d1 $ n "0(5,8) [4 1]" # sound "drum" + # squiz "0 2 5" + |+ squiz "<0 2 3>" + +-- Or again, you can add the number patterns, rather than the control +-- patterns. This is the same: +d1 $ n "0(5,8) [4 1]" # sound "drum" + # squiz ("0 2 5" |+ "<0 2 3>") + +-- See which you prefer to do! + +-- 'saw' is a pattern that slowly moves from 0 to 1 over a cycle. Here +-- I'm slowing it down so it lasts 4 cycles, slowing increasing the +-- speed over that time: +d1 $ n "[0 4 2] [4 1] 3 [2 0] 3 [3 1] 4 4" # sound "cpu" + # squiz 3 + # speed "1 [2 3] 3" + |+ speed (slow 4 saw) diff --git a/study/club/w3.tidal b/study/club/w3.tidal new file mode 100644 index 0000000..6ccb526 --- /dev/null +++ b/study/club/w3.tidal @@ -0,0 +1,232 @@ +-- region Lesson 1: exploring the ‘every’ function, including tackling the meaning of ‘$’ +-- every + +-- 'every' is one of a family of Tidal functions, that takes another +-- function as one of its inputs. + +-- Let's say we had a simple pattern like this: +d1 $ sound "bd sd ~ cp" + +-- ... and we wanted to speed it up like this: +d1 $ fast 2 $ sound "bd sd ~ cp" + +-- ... but only one cycle out of three. + +-- Here's how we'd use 'every' to do that: +d1 $ every 3 (fast 2) $ sound "bd sd ~ cp" + +-- You can read this as "every 3rd cycle, make 'sound "bd sd ~ cp"', +-- go faster by a factor of two." + +-- We'll take this apart to work out why we sometimes use (), and +-- sometimes '$' later. First, lets look at more, practical examples +-- of using 'every'. + +-- We can use every with any function that takes single pattern as +-- input (and returns a transformed version as output). For example, +-- we can use 'hurry' instead of fast: +d1 $ every 3 (hurry 2) $ sound "bd sd [~ bd] [cp bd*2]" + +-- Or use 'rev': +d1 $ every 3 (rev) $ sound "bd sd [~ bd] [cp bd*2]" + +-- Because 'rev' is a single word, we don't actually need to put it in +-- parenthesis: +d1 $ every 3 rev $ sound "bd sd [~ bd] [cp bd*2]" + +-- Here's a trick with using effects as functions.. +-- Lets look at this: +d1 $ sound "bd sd [~ bd] [cp bd*2]" + # squiz "5" + +-- We can treat the '# speed 5' bit as a function. If you think about +-- it, it does something to a pattern, just like 'fast 2' does. + +-- So.. does this work? +d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]" + +-- Yes it does! + +-- You can also add more than one 'every' manipulation, giving them +-- different periods for their first input, to create longer form +-- variety: +d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]" + +d1 $ every 2 (hurry 2) $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]" + +-- keep going.. +d1 $ every 4 rev $ every 2 (hurry 2) $ every 3 (# squiz 5) + $ sound "bd sd [~ bd] [cp bd*2]" + +-- In Tidal, the pattern that a function is manipulating is generally +-- its final input, which makes it easy to 'chain together' functions +-- like this. + +-- Ok as promised, lets go back to our original, simple example: +d1 $ every 3 (fast 2) $ sound "bd sd ~ cp" + +-- Lets go through the three 'inputs' (also sometimes called +-- 'parameters' or 'arguments') for every. + +-- [a] 3 - how often a function is applied +-- [b] fast 2 - the function that is applied +-- [c] sound "bd sd ~ cp" - the pattern that it's applied to. + +-- Looking again at this pattern, you can see that the inputs are +-- given in three different ways: +d1 $ every 3 (fast 2) $ sound "bd sd ~ cp" + +-- '3' is just on its own. It's a single number so tidal has no +-- problem knowing it's a single input. + +-- 'fast 2' is in parenthesis '(fast 2)'. Then the word 'fast' and +-- number '2' are grouped together into a function, _before_ being +-- passed to 'every' as its second input. + +-- 'sound "bd sd ~ cp"' has $ in front. We *could* have done this +-- instead: +d1 $ every 3 (fast 2) (sound "bd sd ~ cp") + +-- That works fine, but '$' does the same kind of job. It passes +-- what's on its left, to the function on its right, as a single +-- parameter. '$' has really low priority, which means everything on +-- its right is worked out first before being passed to the left. +d1 $ every 3 (fast 2) $ sound "bd sd ~ cp" + +-- This saves you from having to match up ( and ) around a function's +-- final input. It doesn't work with anything other than the final +-- input, so unfortunately this _doesn't_ work + +d1 $ every 3 $ fast 2 $ sound "bd sd ~ cp" + +-- The above would work out 'fast 2 $ sound "bd sd ~ cp"' first, and +-- would then try to pass that to 'every' as its second parameter, +-- which doesn't make sense to tidal, so it returns an error. + +-- Note that when Tidal makes an error, if there was already a +-- pattern running, it will keep that going. If you're live coding +-- in front of an audience, you probably don't want an error to +-- result in silence! + +-- endregion + + +-- region Lesson 2: cut vs legato + +d1 $ jux rev $ speed "<1 0.5 0.75>(<3 5>,8)" # sound "bev" # cut 1 + # room 0.4 # sz 0.9 # gain 1.3 + +d2 $ jux rev $ sound "sax(3,8)" # legato 1 # n 3 + # note "<[9 7] 5 [9 12]>" # djf 0.7 # sz 0.4 # room 0.4 + +-- endregion + + +-- region Lesson 3: slice and splice to for perfect spice +setcps 0.6 + +-- Hear it straight +d1 $ splice 8 "0 1 2 3 4 5 6 7" $ sound "break:4" + +-- Now with a more messed-up pattern +d1 $ splice 8 "6 1 [2 3] ~ 4 1 6*2 7" $ sound "break:4" + +-- Try changing the cps to hear it at different speeds + +-- Try manipulating the pattern of slices +d1 $ splice 8 (fast "1 [0.5 0.75]" "6 1 [2 3] ~ 4 1 6*2 7") + $ sound "break:4" + +-- Now try all the above with 'slice' instead of 'splice'. +-- Slice _doesn't_ do the pitching up/down thing to splice the +-- sound to the step. + +-- Here I put six slices from a loop originally in 4/4, to create +-- a 3/4 waltz +d1 $ splice 8 ("0 1 2 3 4 5") $ sound "break:4" # gain 1.1 +d2 $ sound "kick snare*2 clap:4" # speed 2 + +-- endregion + +-- region Lesson 4: chop and striate + +-- Let's take a nice break: +once $ sound "break:8" + +-- We can use 'begin' and 'end' to only play part of the sound, in this +-- case the final quarter of it: +d1 $ sound "break:8*4" # begin 0.75 # end 1 + +-- We can also use 'unit "c"' to change the behaviour of 'speed' so it +-- changes the playback speed to match the cps +d1 $ sound "break:8" # speed 1 # unit "c" # begin 0.75 # end 1 + +-- Lets play four of those to fill the cycle +d1 $ sound "break:8*4" # speed 1 # unit "c" # begin 0.75 # end 1 + +-- Then play with the cps to hear it change, fitting the cps perfectly +setcps 0.8 + +-- Normally, I wouldn't use 'unit', 'begin' and 'end' by hand. Instead +-- I'd use splice / slice from the previous lesson, or 'chop' to cut +-- a sound into bits, and set the length of the loop in cycles with +-- 'loopAt' +d1 $ loopAt 2 $ chop 4 $ sound "break:8" + +-- The above sounds pretty continuous, but it is chopped into four parts. +-- We can hear that by reversing the chopped up parts: +d1 $ loopAt 2 $ rev $ chop 4 $ sound "break:8" + +-- If we slow the pattern we can hear each part separately: +d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8" + +-- Here's a different sample: +d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:9" + +-- Now what happens if we put both breaks in the sequence? +d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8 break:9" + +-- With 'chop', it will play all the parts of break:8, followed by +-- all the parts of 'break:9'. + +-- If we swap 'chop' for its friend 'striate', then parts from the +-- two breaks are instead interlaced: +d1 $ slow 2 $ loopAt 2 $ striate 4 $ sound "break:8 break:9" + +-- Play with that striate value for fun: +d1 $ slow 2 $ loopAt 2 $ striate 32 $ sound "break:8 break:9" + +-- If you use the *same* loop multiple times with striate, it kind +-- of stretches it: +d1 $ slow 4 $ loopAt 1 $ striate 4 $ sound "break:1*4" + +-- Here's what that normally sounds like: +once $ sound "break:1" + +-- 'bev' is an even longer sample.. +d1 $ loopAt 16 $ striate 32 $ sound "bev" + +d1 $ slow 4 $ jux rev $ loopAt 16 $ striate 128 $ sound "bev*4" + +-- Club: striate fun by @vin +d2 + $ every (irand 3) (degradeBy rand) + $ slow ((irand 4)+1) + $ loopAt ((irand 5) +1) + $ striate (irand 64) + -- $ slice 16 "0 1 5 4 8 6 1 0" + $ s "break:10" + # room 0.5 + # cut 1 + # att rand + # hold rand + # rel rand + +-- endregion + +-- TODO: + +-- HIHATS! ho hc +-- (Cut though) + +-- Speed with unit 'c' to make things fit, whatever the cps diff --git a/study/slicing.tidal b/study/slicing.tidal new file mode 100644 index 0000000..8273c34 --- /dev/null +++ b/study/slicing.tidal @@ -0,0 +1,12 @@ +d1 +$ s "jazz" # gain 0.8 + +d2 +$ every 4 (linger (1 / choose[16,8])) +$ every 3 (choose[1/4, 15/16, 1/2, 1/8, 3/4] <~) +$ loopAt 2 +$ chop 32 +$ s "break:3" +# gain 0.7 + +d3 $ s "~ snare:24" # gain 0.7 -- libgit2 0.27.0