diff --git a/backlog.md b/backlog.md index ec2873d..a0df689 100644 --- a/backlog.md +++ b/backlog.md @@ -2,23 +2,41 @@ ## Worksheet - Jazz noise: basis for jazzy drums / hip instru? +## Lessons + +- Reread building up +- Poetry +- Weave / Snowball +- W7 / W8 +- Melodies from forum + ## Prod + + +- [DNB] Sensation octobre Nass guitar + + - Crapeau HipPo: Clav sur rythme hip-hop manuel - Break britafuninnique: boucle hip hop breatbeat piano attend un lead - Marche vertige: vertige vibration attend drum militaire +- Wake the Funk: WIP techno funk résolue + hats + - Morning flowers: breakbeat bassline funky - [Hardcore] Noise in the wires +- [Transe] Tentative (Didgeri) Doo -- Le naufrage! Funkpiano 110BPM +- Le naufrage! Funkpiano 110BPM +- Vertige expérientiel : Techno progressive+ résolue bass laggy+ forks - Cuba space program: Techno-clave + vibraphone, bonne montée attends drop! ## Copycat +- 44 More - Bad guy: getting there! ## Remix diff --git a/copycat/44.tidal b/copycat/44.tidal new file mode 100644 index 0000000..9f7e073 --- /dev/null +++ b/copycat/44.tidal @@ -0,0 +1,33 @@ +do +-- resetCycles +setcps (130/60/4) +d1 + $ superimpose ((# "808bd:1") . (# cut 11) + . (|* gain 0.8) + . (# lpf 200) + ) + $ cat [ -- Beat pattern + "k ~ ~ k ~ ~ k ~", "~ k k ~ k <~ ~ ~ k> <~ k> k" + ] + # "808bd" + -- # gain 0.9 + -- # cut 1 + -- # legato 0.5 +d9 $ "arpy/2" # gain 0.6 +d2 $ "~ cp" # lpf 2000 # gain 0.9 +d3 + $ "dr*<8!3 [16 8!7]>" + # "drum:8" + # room 0.2 + # size 0.2 + # dry 2 + # legato 0.5 + # gain 0.5 + +8 8 [16 8 . 8] + +once $ "[kick:3,reverbkick]" # gain 0.6 # lpf 1000 # legato 0.2 +# + +once $ note (arp "up" "c5'sevenSus4'5") + # "supersquare" # gain 0.8 # legato 8 # release 4 diff --git a/copycat/bad_guy.tidal b/copycat/bad_guy.tidal index 109330d..63ce2a9 100644 --- a/copycat/bad_guy.tidal +++ b/copycat/bad_guy.tidal @@ -183,14 +183,13 @@ d4 -- Brass voice # legato "<0.75!7 1>" # room 0.2 # gain 0.4 - d6 -- synth Chorus $ note (cat [ - -- "","","","","","","","", -- Intro - -- "","","","","","","","", -- White shirt - -- "","","","","","","","", -- Bruises - -- "","","","","","","","", -- So you're a tough guy - -- "","", -- BAD GUY + "","","","","","","","", -- Intro + "","","","","","","","", -- White shirt + "","","","","","","","", -- Bruises + "","","","","","","","", -- So you're a tough guy + "","", -- BAD GUY "g d ~ g . df d df bf", "g d ~ g . df d df bf", "g d ~ g . df d df bf", diff --git a/live/chill/dub/riddim_du_dim.tidal b/live/chill/dub/riddim_du_dim.tidal new file mode 100644 index 0000000..7708f0a --- /dev/null +++ b/live/chill/dub/riddim_du_dim.tidal @@ -0,0 +1,114 @@ +-- Dub du dim: A retravailler, cuivres/voices? + +do +-- resetCycles +setcps (120/60/4) +let melody = "0 <0 <2 -2>>" +d1 --Kick : un low et un high pour donner du relief + $ whenmod 32 16 (superimpose ( + (|> "rave:6") + . (# cut 11) + . (# begin 0.75) + . (# gain 0.8) + )) + -- $ "k" -- Intro + $ "k k k*<1!3 <2 4>>" -- RUN! + -- $ "k . k(3,8)" -- Hip chaloupe + # "[jazz,kick:17]" + # gain 1 + --Fx : kick étouffé, lpf Puis reverb + # lpf 1000 + # room (0.8 * "<0!24 0.1 0.2 0.3 0.4 0.5!4>") + # dry 1 # sz 0.5 +d2 --Basse repetitive avec fort lpf + $ jux id + $ note ("c*<1 2> c*<1!3 2> c(<1!7 2 1!7 4 3!4 1!4>,8) [~ c]" + + melody + ) + # "bass3:6" + # gain (slow 16 $ range 0.65 0.8 (saw + perlin/2)) + # lpf (slow 32 $ range 2500 200 perlin) + # sz 0.5 +d3 -- clap si grave qu'on dirait un pas de géant distant + $ mask "" $ "cp" + # note (-12) + # lpf 200 + # room 0.2 # size 0.2 # dry 1 + # gain (slow 16 $ range 0.8 1.6 saw) +d8 -- Guitar second background coming loop + $ mask "" + $ scramble "<1!2 [1 2]!2 8!4> . 4 1" + $ "fguitar:22" # gain 0.8 # cut 8 + # gain (slow 8 $ range 0.2 0.5 saw) +d4 -- Guitar lead contretemps! + $ note ("~ 0*<1!3 <2 1>> ~ 0*<1!7 2>" + + melody + "e'min'4" + ) + # "bsguitar:3" + # gain (slow 16 $ range "<1!16 0.65!16>" "<0.5!16 0.65!16>" isaw) + # room (slow 16 $ range 0.3 0.7 saw) + # sz 0.4 +d7 -- Cuivres lancinants + $ mask "" + $ swing 2 + $ slow 2 + $ arp (slow 4 "") + $ note ( + "e2'min'2" |+ melody) + # "brass:4" + # legato 2 + # room 0.8 + # gain 0.5 + # pan 0.6 + +d9--- piano descente en conclusion` + $ mask "" + $ "fepiano:7" + # cut 31 + # gain 0.65 + + + --- cuivres riff boucle courte + +-- Fguitar 20 chaleureuse breaks? + +-- region SANDBOX +d6 -- Cuivre riff concluant! + -- $ mask "" + -- $ whenmod 4 3 (slice 4 "0*<2 4>") + $ loopAt 2 + $ "brass:24" + # gain (slow 24 $ range 0.2 0.4 saw) + # room 0.4 + # cut 6 + # pan 0.2 + + +-- # gain 0.5 +d4 -- Pluck melodie? + $ whenmod 4 2 (swing 4) + $ off "e" (|+| note "12 0(<1 3>,8)") + $ slow 4 + $ arpeggiate + $ note ("c'7f10'8") + # "pluck:8" # gain 0.6 + + + +once $ "fpiano:10" # cut 9 # gain 0.8 + +once $ slice 4 (3) $ "rave:6" +# gain 0.8 +# cut 21 +-- # note (-12) +-- # room 0.8 +-- # dry 0.25 + +-- TECHNO 2-sec :) +do + d1 $ "jazz*4" + d2 $ "hh*8" # gain 0.8 + d10 $ slice 8 (run 8) $ scramble 32 $ "bev" # gain 0.8 # cut 4 + +--- synthé pont reprise mélodie +--- toys space invaders :D diff --git a/live/dnb/automne_electrique.tidal b/live/dnb/automne_electrique.tidal new file mode 100644 index 0000000..fbe15a1 --- /dev/null +++ b/live/dnb/automne_electrique.tidal @@ -0,0 +1,57 @@ +-- Sensation Octale +-- DNB GUITAR +-- Timeline | Intro > Montee > DropFull > PontGuitare > Montee > DropFullGuitar > Outro +-- Measures | 0-7 > 8-31 > 32-63 > 64-71 > 72-95 > 16 > 16 +-- 1 Kick | .. .. XXXXXXX . X . . . . . . . . ... XXXXXXXXXXXX X . ..X .. +-- 2 drRoll | ...XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX +-- 3 Guitar | .........................xxxxxxxxxxxxxxFFFFFFFxxxxxxxxxxxxxxxx........... +-- 4 Bass | bbbbbbbbbbbbbbbbbxxxxxxxxxxxxx.......................xxxxxxxxxxxxxxbbbbbbbbb +do +resetCycles +setcps (160/4/60) +d1 -- Poum tchak + $ mask "" -- Orchestration + $ fix ( + (# s "[sn:20,snare:8]") + . (# n (slow 4 $ "<2!3 20>")) + . (# note 4) + . (|* gain 1.1) + ) (s "s") + $ fix (# s "[bskick,jazz]") (s "b") + $ s "b? ~ s ~ ~ b s <~ <~ s>>" + # gain 1.1 +d2 -- drumroll + $ mask "" -- Orchestration + $ whenmod 4 3 (jux (fast 2 . rev)) + $ fast "4 <8 16>" + $ s "[drum:8,dr]" + # pan (slow 8 $ range 0.1 0.9 sine) + # gain (slow 16 $ range 0.65 0.95 sine) +d3 + $ mask "" -- Orchestration + $ sometimesBy "" (|* gain (slow 32 $ range 1 0.75 saw)) + $ slice 8 (iter (slow 8 $ "[4|8]") $ run "<4!8 8!8>") + $ "fguitar" + # n ("<8!4 10!4 8 10 10 8>") + # cut 3 + # gain 0.9 + # room 0.3 + # size 0.4 + # dry 1 + # pan 0.35 +d4 -- BASSLINE ELECTRIQUE + $ mask "" -- Orchestration + $ sometimesBy "" (|* gain (slow 24 $ range 1 1.2 saw)) + $ slice 8 ("<0!3 4>" + run 8) + $ "fbass:10" + # pan 0.8 + # cut 4 + # crush "<16!28 12 10 9 8 5!32 5!32 5!12 8 9 10 12 16!16>" +d10 -- Toys vent + $ mask "]!56>" + $ whenmod 16 12 (jux rev) + $ every 8 (# gain 0.9) + $ s "space:3" + # speed (range 0.15 0.3 perlin) + # gain (slow 16 $ range 0.25 0.45 saw) + # pan rand diff --git a/live/fusion/cuba_space_program.tidal b/live/fusion/cuba_space_program.tidal index 3d5fc54..eaeed4d 100644 --- a/live/fusion/cuba_space_program.tidal +++ b/live/fusion/cuba_space_program.tidal @@ -3,29 +3,29 @@ solo 2 -- TODO: Kick in at 8, current bass=kick -- Intro Bass in Kick in Bass cut/montee drop -- pont -- intro --- 0 4 8 20 28 36 40/0 - +-- 0 4 8 20 28 36 40/0 do -resetCycles +-- resetCycles setcps 0.5 d1 $ mask "" -- Orchestra/40 $ "jazz*4" - # gain 0.65 + # gain 0.95 d2 -- Son clave cubain $ mask "<[t f!3] [t f!2] [t f] t t!16 [t f!3]!8 t!8 [t f!7]!4>" -- Orchestra/40 + -- ^: FIXME Replace clave at drop with kick $ "c c ~ c ~ c c ~" # "808hc" # n "<0!8 3 3 0 0 0 0 3 3>" # room 0.1 # sz 0.3 # dry 1 - # gain 0.8 + # gain 0.5 d3 -- Glitch clap dark $ mask ("") $ whenmod 20 16 (# note "<0 -3 -7 -10>") $ "~ ~ ~ cp" # lpf 2000 # lpq 0.2 # gain 0.9 -d4 -- Ritournelle 3/2 vibraphone +d4 -- Ritournelle 3/2 vibraphone FIXME $ mask "" -- Orchestra/40 $ whenmod 40 36 (|* gain (slow 4 $ range 1 0.4 isaw)) $ whenmod 8 6 (juxBy 0.5 (rev . (|* gain 0.4))) @@ -36,7 +36,7 @@ d4 -- Ritournelle 3/2 vibraphone )) # "supervibe" # accelerate (0.01) - # gain 0.45 + # gain (slow 16 $ range 0.05 0.35 saw) d5 $ mask "" $ jux id @@ -67,7 +67,7 @@ d9 -- Montée Shepard! $ sometimesBy "1 0" (# gain (range 0 0.5 saw)) $ sometimesBy "0 1" (# gain (range 1 0.5 isaw)) $ "s" - # gain 0.5 + # gain 0.75 once $ "bev" # gain 0.6 # cut 21 diff --git a/live/hardcore/noise_in_the_wires.tidal b/live/hardcore/noise_in_the_wires.tidal index 9ce81b9..21ae827 100644 --- a/live/hardcore/noise_in_the_wires.tidal +++ b/live/hardcore/noise_in_the_wires.tidal @@ -2,7 +2,7 @@ -- TODO guitare do - -- resetCycles + resetCycles setcps (90/60/4) let masked = sometimes (degradeBy "0 0!6 <0!3 1>") d1 diff --git a/live/hip/chaude_civ.tidal b/live/hip/chaude_civ.tidal index f27060d..1df7d69 100644 --- a/live/hip/chaude_civ.tidal +++ b/live/hip/chaude_civ.tidal @@ -6,17 +6,16 @@ do setcps (90/4/60) d1 -- Kick base chaloupé ? $ mask "" - $ juxBy 0.4 ((|* gain 0.8) . rev) $ " ~ > ~ k [k|k*2] k" # "reverbkick" # room 0.1 # sz 0.1 - # gain (slow 32 $ range 0.5 0.65 saw) + # gain (slow 32 $ range 0.5 0.7 saw) d2 -- Breakbeat $ mask "" $ slice "<8!12 4 4 2 [4 . 8 4]>" ("<0!3 4>" + "0 1 2 3") $ loopAt 2 $ "fbonus:9" - # gain 0.8 + # gain 0.7 # cut 2 d3 -- Drumroll metal $ fast "<4 4 8 4 4 [4 . ~ 8] 8 <[16 8] 16>>" diff --git a/live/remix/kanye_fly.tidal b/live/remix/kanye_fly.tidal index b712894..5e2f3a8 100644 --- a/live/remix/kanye_fly.tidal +++ b/live/remix/kanye_fly.tidal @@ -1,4 +1,3 @@ -d1 $ "bd" once $ slice 32 "1*4" $ "kanye" # cut 21 @@ -70,8 +69,6 @@ d4 -- Kanye who? # gain 0.65 - - once $ "kanye" # begin 0.835 -- Fly awayyyyy # cut 3 -- 16 @@ -80,7 +77,6 @@ once $ "kanye" # begin 0.835 -- Fly awayyyyy - do let b = 0.835 let d = (10/60) @@ -94,3 +90,46 @@ d4 $ "kanye/4" # cut 21 # gain 0.8 + + + +-- region GLAD To Fly Techno +do + setcps (120/60/4) + -- resetCycles + -- Loop 0 4 8 12 16 20 24 32 40 48 52 60 68 72 80 88 + -- Intro | Wild+ |Fly+ |Ah++|WildFLY|Ah-|Fly|A-a-a-away EOF + d1 + $ mask "!4 !4 t!16 f!12 t!8 t f!3 t!8 t!6 f f t!4 t(1,4)!4 f!8>" + $ fast "<4!3 <2!3 [8 4]>>" + $ "[jazz,techno]" + # gain 0.8 + d2 + $ jux rev + -- $ sometimesBy "" (slow 4 . (|* gain (slow 8 saw))) + $ "hh(<5!4 3 3 5 3>,8) ho" + # n "0 <0 0 1 2 3 4 5 6>" + # gain 0.9 + d4 $ slice 8 (cat [ + "", "", "0", "", -- 0 One glad morning + "0/4", "", "", "", -- 4 One glad morning, when this life is over + "0/4", "", "", "", -- 8 One glad morning, when this life is over + "~ 1", "1*2", "1*4", "1*[8 2]", -- 12 Wild + "1", "1*2", "1*4", "1*[8 2]", -- 16 Wild + "1/4", "", "", "", -- 20 WILD, Fly away... + 2, 2, 2, "2*4", 2, 2, 2, "2*2", -- 24 Ooh euh + 3, 3, "3*4", 3, "3*[4 2]", "3*[8 4]", "3*16", "3*[16 1]", -- 32 AaAaAaAaAa piano fou! + 4, 4, "4*2", 4, "4*4", "4*4", "4*8", "4*[16 2]", -- 40 Wild - Fly - WILD WILD WILD WILD Fly + 5, 5, 5, 5, -- 48 Fly.. ah + 5, 5, 5, 5, "", "", "", 5, -- 52 Fly.. ah fly away + "", "", "", 5, "", "", "", 5, -- 60 Fly.. ah fly away + "", 5, "", "", -- 68 Fly away, Fly away + 7, 7, 7, 7, "", 7, 7, "7/4", -- 72 Ah ah ah fly away + "7/2", "", "7/4", "", "7/2", "7/4", "7/4", "7/4" -- 80 Ah ah ah fly away + -- 88 EOF1 + ]) $ "kanye" + # gain 0.9 + # legato 2 + # cut 4 + + -- delay / delaytime / delayfeedback / cutoff / resonance / room / size diff --git a/live/techno/foret_noire.tidal b/live/techno/foret_noire.tidal new file mode 100644 index 0000000..6c21d38 --- /dev/null +++ b/live/techno/foret_noire.tidal @@ -0,0 +1,17 @@ + +do +let melody = "" +setcps (120/60/4) +d1 $ "jazz*4" -- Rythme des tambours +d2 -- Hypnose des mains + $ "~ cp" + # note ("<0!3 <2 -2>>") + # room 0.4 + # dry 1 + # gain 0.9 +d4 -- Chant lunaire + $ note "0(<4!3 <3 5>>,8)" + # note (arp "up" (slow 4 melody)) + # "supersquare" + # gain 0.6 + # legato 8 # release 4 diff --git a/live/techno/funk/naufrage.tidal b/live/techno/funk/naufrage.tidal index f58da52..530d50a 100644 --- a/live/techno/funk/naufrage.tidal +++ b/live/techno/funk/naufrage.tidal @@ -2,9 +2,10 @@ -- Tags: Techno, funk, piano -- Ready: 5/10 -- Intro lead piano -resetCycles +-- TODO: "Grande theorie" avant drop kick do + -- resetCycles solo 1 -- KICK! solo 2 -- Hats rolling solo 3 -- LEAD piano @@ -21,7 +22,7 @@ do $ superimpose (const $ stut' 4 "" (("q" <~) . (|* gain 0.85)) $ "ho" # n "<[2|4|5] 1>" - # gain (slow 16 $ range 0.5 0.95 saw) + # gain (slow 16 $ range 0.5 0.85 saw) ) $ juxBy "<<0.2 0.8> 0.5>" (rev . (hurry 2)) $ note (stack [ diff --git a/live/transe/doo.tidal b/live/transe/doo.tidal index 3312b72..dd4d937 100644 --- a/live/transe/doo.tidal +++ b/live/transe/doo.tidal @@ -26,6 +26,7 @@ d3 -- Snare roll # note "<0!8 -2!4 -4!2 -8!2>" # gain (slow 16 $ range 0.65 1.2 sine) # pan (slow 4 $ range 0.2 0.8 sine) + d4 -- Saxeridoo $ juxBy 0.8 rev $ whenmod 64 8 (slice 8 (run "<2!4 8!3 16>")) @@ -38,6 +39,7 @@ d4 -- Saxeridoo # gain (slow 16 $ range 0.9 1.25 perlin) # room (slow 64 $ range 0.1 0.4 sine) # sz 0.3 # cut 4 + d5 $ superimpose (off "h" (|+ note "<0!4 12!4>")) $ note ("c3'maj" + " g>>") diff --git a/study/club/fotw/snowball.tidal b/study/club/fotw/snowball.tidal new file mode 100644 index 0000000..a09b7f6 --- /dev/null +++ b/study/club/fotw/snowball.tidal @@ -0,0 +1,41 @@ +-- snowball takes a pattern, applies the function to it (the third argument), +-- then applies it again to the result, and again to the result of that, and +-- so on, the number of times given in the first argument. Then it +-- combines all the results together pairwise, with the function given in +-- the second argument. + +-- Lets start with a simple tom pattern: +d1 $ s "lt mt ht ~" + +-- Then apply 'hurry 2' to it each time, to a depth of 4 'recursions' +d1 $ snowball 4 (overlay) (hurry 2) $ s "lt mt ht ~" + +-- You can hear the 'hurried' layers built up. The first time you hear the +-- original pattern, then that pattern combined with itself (so it sounds +-- louder), then you start hearing the 'hurried' layers added over the third +-- and fourth cycle. + +-- This doesn't work too well really - I don't think it should be combined +-- with itself that second time. Here's an alternate version that doesn't +-- do that: +snowball' :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +snowball' depth combinationFunction f pattern = cat $ take depth $ + scanl combinationFunction pattern $ drop 1 $ iterate f pattern + +d1 $ snowball' 4 (overlay) (hurry 2) $ s "lt mt ht ~" + +-- Instead of 'overlay' to play the layers on top of each other, we +-- can use a function to combine them. For example using '+' on a +-- snowballed number pattern, to add the layers together: +d1 $ n (scale "major" $ snowball 4 (+) (slow 1.5) "0 1 2 3") + # s "supermandolin" + # legato 3 + +d1 $ n (snowball 4 (+) (slow 1.5) "0 1 2 3 4 5 6 7") + # s "cpu" + # speed 2 + +d1 $ (note $ scale "hexPhrygian" $ "0 . 2 3 ~ . 0 1 . -1 -2") #s "gtr" + +d1 $ (note $ scale "hexPhrygian" $ + snowball 4 (+) (slow 2) "0 . 2 3 ~ . 0 1 . -1 -2") #s "gtr" diff --git a/study/club/fotw/weave.tidal b/study/club/fotw/weave.tidal new file mode 100644 index 0000000..58d7fd0 --- /dev/null +++ b/study/club/fotw/weave.tidal @@ -0,0 +1,128 @@ +d1 $ weave 16 (pan sine) + [sound "bd sn cp", + sound "casio casio:1", + sound "[jvbass*2 jvbass:2]/2", + sound "hc*4" + ] + + +-- Function of the Week: "weave" ! + +-- Weave is an interesting one. It's used to 'weave together' a list +-- of patterns, using an additional control pattern. So it's a bit +-- like the warp and weft of a textile weave. + +-- Lets start with some numbers: +d1 $ n "0 1 2 3" # s "numbers" + +-- Lets first understand what happens if you use weave on a single +-- pattern: +d1 $ weave 4 (pan saw) + [n "0 1 2 3" # s "alphabet"] + +-- You can hear the pattern panning from left to right over four +-- cycles. + +-- In the above, the '4' is used to slow down the 'pan saw' effect, +-- before it's applied to the 'n "0 1 2 3" # s "numbers"' pattern. It +-- sounds identical to the following: + +d1 $ n "0 1 2 3" # s "numbers" + # pan (slow 4 saw) + +-- So why not just do that - what's the point of the weave function? +-- Lets hear what happens when you use it with two patterns: + +d1 $ weave 4 (pan saw) + [n "0 1 2 3" # s "numbers", + n "0 1 2 3" # s "alphabet" + ] + +-- Aha! You should be able to hear that the patterns are placed at +-- different parts of the panning effect. So 'weave' is acting a bit +-- like a wacked-out 'stack'. The patterns are stacked up, each with +-- the 'pan' control pattern applied, but with the pan control shifted +-- so that one is at the start of the pan, the other is halfway +-- through. They're kind of chasing after each other across the pan. + +-- The following sounds identical to the above: + +d1 $ stack [n "0 1 2 3" # s "numbers" + # pan (slow 4 saw), + n "0 1 2 3" # s "alphabet" + # pan (2 <~ (slow 4 saw)) + ] + +-- Here's a more musical example: +d1 $ weave 4 (pan saw) + [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2, + fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2" + ] + +-- If we add another pattern, so that we now have 3, things go +-- a bit off-kilter: +d1 $ weave 4 (pan saw) + [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2, + fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2", + sound "~ clap:3*2" # speed 2 + ] + +-- That's because three events are spreading out over four cycles, so +-- they're out by four thirds of a cycle, which sounds like being out +-- by a third of a cycle. Sounds interesting! + +-- Once we add a fourth, things fall back into a 4:4 structure: +d1 $ weave 4 (crush saw) + [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2, + fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2", + sound "~ clap:3*2" # speed 2, + sound "bd(3,8,<0 2>)" # shape 0.85 + ] + +-- 'saw' gives a smooth, linear movement from left to right. Some more +-- to experiment with (replace `pan saw` for one of these): + +-- pan "0 0.25 0.5 0.75" +-- pan sine + +-- It works for things other than panning, too, try: +-- crush (saw * 8) +-- vowel "a e i o u" + +-- It works with global effects like reverb too, but you have to put +-- each pattern on its own 'orbit', so that they have separate global +-- effects: +d1 $ weave 8 (room saw # sz saw) + [n "[0*2 0*3, [~ 3]*2, 4(3,8,<0 2>)]" # s "cpu" # squiz 2 # orbit 0, + fast 2 $ brak $ n "0 4 3 <[~ 3] 3>" # s "cpu2" # orbit 1, + sound "~ clap:3*2" # speed 2 # orbit 2, + sound "bd(3,8,<0 2>)" # shape 0.85 # orbit 3 + ] + +-- Things get especially weird when you swap things round so that it's +-- the samples/notes that are being applied to effect patterns. + +d1 $ weave 8 (note "c e f g" # s "supermandolin" # legato 2) + [vowel "a e i"] # gain 1.3 + +-- and with more patterns: +d1 $ weave 8 (every 2 rev $ n (scale "ritusen" "0 .. 7") + # s "rash" + ) + [vowel "a e i", + vowel "o(5,8,<0 2>)", + squiz "0 3*2 4 7" + room "0 0.25 0.7 0.99" # orbit 3 + ] |+ n 24 + + +-- There's also a function 'weaveWith', which works with functions, +-- rather than control patterns.. +d1 $ weaveWith 8 (every 2 rev $ n (scale "ritusen" "0 .. 7") + # s "rash" + ) + [(+| vowel "a e i*2"), + (+| n "0 12*2 0 12"), + hurry 2, + off 0.25 (|+ n "-24") . struct "t(5,8,<0 2>)" . hurry 4 + ] |+ n 24 diff --git a/study/club/melodies.tidal b/study/club/melodies.tidal new file mode 100644 index 0000000..0bd14c0 --- /dev/null +++ b/study/club/melodies.tidal @@ -0,0 +1,15 @@ +do + let dascale = "hirajoshi" + let chord = "'maj" + let melo = "0 3 4 7" + let root = "" + d1 $ n (scale dascale (chord + melo) + (root + "<-12 -7>")) + # s "superpiano" + -- d1 $ every 3 (rev) $ n (scale dascale (melo) + root) # s "superpwm" + d1 $ every 2 (arpeggiate) + $ n (scale dascale (chord + melo) + (root + "<-12 -7>")) + # s "superpiano" + +do +let tonal root mode = note . (|+ root) . scale mode +d1 $ tonal "<0 3>" "major" $ "0 2 4 7" diff --git a/study/club/poetry.tidal b/study/club/poetry.tidal new file mode 100644 index 0000000..57c6393 --- /dev/null +++ b/study/club/poetry.tidal @@ -0,0 +1,18 @@ + +d3 $ s "cpu2:9*4" + # gain (range 0.7 0.8 rand) + # smear (range 0 2 rand) + # delay 2 # dt "x" + +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 diff --git a/study/club/w7.tidal b/study/club/w7.tidal new file mode 100644 index 0000000..9dae89d --- /dev/null +++ b/study/club/w7.tidal @@ -0,0 +1,148 @@ +-- Composing patterns together + +-- We've already looked at different ways of composing patterns +-- together. Something as simple as this is a composition: + +d1 $ fast "1 2 3 4" $ sound "lt mt ht bd*2" + +-- Not a super interesting one, but it composes together a pattern of +-- densities, and a pattern of sounds, to create a new pattern that is +-- more than the sum of its parts. + +-- In this lesson though we're going to look at ways to compose what +-- you could call 'independent' patterns, where one isn't used to +-- manipulate the other. + +-- Tidal is often used in live situations, but there are some +-- functions that help you assemble multiple patterns into something +-- like a complete 'piece', such as a structured four-minute track. + +-- Before we get to that, lets look at some extra-simple ways of +-- composing patterns together.. as they can be surprisingly useful + +-- First, there's `overlay` that simply plays the two given patterns +-- at the same time: +d1 $ overlay (fast "1 2 3 4" $ sound "lt mt ht ~") + (sound "clap:4(3,8)" # speed 2) + +-- Similar to this is `stack`, which lets you overlay any number of +-- patterns on top of each other. People tend to use this rather than +-- `overlay`, as it's more flexible: +d1 $ stack [(fast "1 2 3 4" $ sound "lt mt ht ~"), + (sound "clap:4(3,8)" # speed 2), + sound "[kick:5(5,8), snare:3(7,16,3)]" + ] + +-- The above composes a list of three patterns together. You can see that +-- a list is given using square brackets ('[' and ']'), with the patterns +-- in the list separated by commas (','). You have to remember *not* to +-- put a comma at the end of the list, only between the elements. + +-- The above might not seem too useful, as you could do the same with +-- separate patterns. This sounds exactly the same as the above: +d1 $ fast "1 2 3 4" $ sound "lt mt ht ~" +d2 $ sound "clap:4(3,8)" # speed 2 +d3 $ sound "[kick:5(5,8), snare:3(7,16,3)]" + +-- Remember though that stack combines everything into a single +-- pattern. This is useful as you can manipulate all those patterns as +-- one. For example: +d1 $ chunk 4 (hurry 2) $ + stack [(fast "1 2 3 4" $ sound "lt mt ht ~"), + (sound "clap:4(3,8)" # speed 2), + sound "[kick:5(5,8), snare:3(7,16,3)]" + ] + +-- Or adding a parameter that applies to the whole stack: +d1 $ stack [(fast "1 2 3 4" $ sound "lt mt ht ~"), + (sound "clap:4(3,8)" # speed 2), + sound "[kick:5(5,8), snare:3(7,16,3)]" + ] # squiz "<0 2>" + +-- So `overlay` and `stack` stack things up, so that they happen at +-- the same time. Howabout sticking things together over time, so they +-- happen one after another? + +-- Like overlay and stack, there is one function, 'append' for +-- composing two patterns together, and another, 'cat' for composing a +-- list of patterns together. + +-- For two patterns: +d1 $ append (fast "1 2 3 4" $ sound "lt mt ht ~") + (sound "clap:4(3,8)" # speed 2) + +-- For a list of patterns: +d1 $ cat [fast "1 2 3 4" $ sound "lt mt ht ~", + sound "clap:4(3,8)" # speed 2, + sound "[kick:5(5,8), snare:3(7,16,3)]" + ] + +-- Again, you'll see `cat` used more often than `append`. + +-- `append` and `cat` maintain the original 'density' of the patterns, +-- taking one cycle per cycle. + +-- There are variants `fastappend` and `fastcat`, that take a cycle +-- from each of the patterns, and squash them all into a single cycle: + +-- For two patterns: +d1 $ fastappend (fast "1 2 3 4" $ sound "lt mt ht ~") + (sound "clap:4(3,8)" # speed 2) + +-- For a list of patterns: +d1 $ fastcat [fast "1 2 3 4" $ sound "lt mt ht ~", + sound "clap:4(3,8)" # speed 2, + sound "[kick:5(5,8), snare:3(7,16,3)]" + ] + +-- That's fine, but what if you don't want to loop between patterns a +-- cycle at a time, but have something between a `stack` and a `cat`, +-- where you can have the patterns overlap? `seqPLoop` is one answer. + +-- With `seqPLoop`, you say when each pattern starts and stops. +-- Lets first emulate the `cat` from earlier, by having each +-- pattern last one cycle. +d1 $ seqPLoop [(0, 1, fast "1 2 3 4" $ sound "lt mt ht ~"), + (1, 2, sound "clap:4(3,8)" # speed 2), + (2, 3, sound "[kick:5(5,8), snare:3(7,16,3)]") + ] + +-- Now let's adjust the starts and stops, so the first two overlap by +-- a pattern, then there's a gap of a cycle before the last one plays: +d1 $ seqPLoop [(0, 2, fast "1 2 3 4" $ sound "lt mt ht ~"), + (1, 3, sound "clap:4(3,8)" # speed 2), + (5, 6, sound "[kick:5(5,8), snare:3(7,16,3)]") + ] + +-- If you want to use the same pattern more than once, you can give it a name +--, like this: +let florence = fast "1 2 3 4" $ sound "lt mt ht ~" +in +d1 $ seqPLoop [(0, 2, florence), + (1, 3, sound "clap:4(3,8)" # speed 2), + (3, 4, sound "[kick:5(5,8), snare:3(7,16,3)]"), + (3, 5, florence # coarse 5) + ] + +-- If you don't want the pattern sequence to loop, then use +-- seqP. You'll need to use something like `qtrigger`, so it starts +-- from cycle 0 +d1 $ qtrigger 1 $ seqP [(0, 2, fast "1 2 3 4" $ sound "lt mt ht ~"), + (1, 3, sound "clap:4(3,8)" # speed 2), + (5, 6, sound "[kick:5(5,8), snare:3(7,16,3)]") + ] + +-- Don't forger you can stack seqPLoop: +d3 $ stack [ + seqPLoop [ + (0, 2, s "[bd*2] hh bd sn:8"), + (1, 3, s "[hh*4] bd bd sn:8"), + (2, 4, s "bd bd sn:8 sn:8"), + (4, 5, s "bd sn:8 [bd*2] sn:8") + ], + seqPLoop [ + (0, 2, s "jvbass(3,8)"), + (2, 4, s "jvbass(5,8)"), + (4, 5, s "jvbass*4" # speed 1.1) + ] +] diff --git a/study/club/w8.tidal b/study/club/w8.tidal new file mode 100644 index 0000000..d5dd29a --- /dev/null +++ b/study/club/w8.tidal @@ -0,0 +1,202 @@ +-- region Lesson 1 SHIFTING TIME + +-- Lets start with a rhythm: +d1 $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2" + +-- That's repeating nicely. Keep it running, then run this: +d1 $ 0.25 <~ (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2") + +-- If you switch between them, you can hear the pattern is shifting in +-- time. The `0.25` means it's shifting by a quarter of a cycle. + +-- You only hear any difference between them at the point where you +-- switch to the other one. You're jumping forward / backward in time, +-- but once you're there, nothing has changed. (!) + +-- Ok, time travel is difficult to talk about. + +-- Lets visualise this, compare these two: +drawLine "a b c d" + +drawLine $ 0.25 <~ "a b c d" + +-- You can see the a b c d sequence is the same, but in the latter +-- case, the cycle begins on the 'b'. + +-- So '<~' has moved us _forward_ into the future. So shouldn't it be +-- '~>', rather than '<~'?? Well, we might have moved into the future, +-- but it's all relative - from the perspective of the pattern, it's +-- moved backwards into the past. Furthermore, while we like to think +-- about us moving forwards into the future, from the perspective of +-- the future, it's moving backwards into the past. Furthermore +-- different human cultures think about time in different ways. + +-- Anyway, '~>' does indeed exist, compare these two: + +drawLine $ 0.25 <~ "a b c d" + +drawLine $ 0.25 ~> "a b c d" + +-- Time is most interesting if you keep jumping around +-- For example jump every 3 cycles: +d1 $ every 3 (0.25 <~) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2" + # crush 4 + +-- Jumping in the other direction has quite a different feel: +d1 $ every 3 (0.25 ~>) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2" + # crush 4 + +-- You can also use a pattern for the time shift amount: +d1 $ "<0 0.25 0.75>" ~> + (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" # sound "cpu2" # crush 4) + +-- Even with this straightforward shifting, things quickly start +-- sounding 'random', until your ears lock on to the longer loop.. + +-- SIDETRACK - a note on syntax.. + +-- Unfortunately this use of the dollar *doesn't work*: +d1 $ "<0 0.25 0.75>" ~> $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" + # sound "cpu2" # crush 4 + +-- This is because like all operators, you can't use a dollar to group +-- together a pattern to send to `~>` in this way. haskell gets +-- confused about seeing two operators ('$' and '~>') next to each +-- other. + +-- So you have to use parenthesis: +d1 $ "<0 0.25 0.75>" ~> (n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" + # sound "cpu2" # crush 4) + +-- Or another way around this is to wrap the *operator* in +-- parenthesis, then you can use it like a normal function: +d1 $ (~>) "<0 0.25 0.75>" $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" + # sound "cpu2" # crush 4 + +-- Or wrap the first input and the operator in parenthesis: +d1 $ ("<0 0.25 0.75>" ~>) $ n "[0 [1 0] 6*2 [3 4*2], 8(5,8)]" + # sound "cpu2" # crush 4 + +-- This all works nicely with chopped-up loops: +d1 $ every 2 ("e" <~) $ every 3 (0.25 <~) $ + loopAt 1 $ chop 8 $ sound "break:8" + +-- endregion + +-- region Lesson 2 Binary patterns + +-- The patterns you send to SuperDirt tend to contain values of type +-- String (for words), Double (for decimal numbers) or Int (for whole +-- numbers). One pattern type you probably won't send to SuperDirt is +-- of type Bool - short for Boolean. + +-- Boolean values can be either True or False. You've probably seen +-- then used with with 'struct', e.g.: + +d1 $ struct "t f t t f t f f" $ sound "snare:4" + +-- 'struct' provides structure for the pattern on the right; whenever +-- there's a 't' (i.e., a true value) in the boolean pattern, the +-- snare fires. + +-- It works with euclidean syntax too: +d1 $ struct "t(3,8)" $ sound "snare:4" + +-- The above creates a new pattern with three events per cycle, +-- according to a Euclidean pattern. + +-- Lets have a look at that euclidean pattern: +drawLine $ struct "t(3,8)" "a" + +-- So what do you think would happen if you changed that 't' (for +-- true) for an 'f' (for false)? Lets try: +drawLine $ struct "f(3,8)" "a" + +-- Lets listen to that structure too: +d1 $ struct "f(3,8)" $ sound "snare:4" + +-- You can see and hear that the *inverse* of the Euclidean pattern is +-- played. What was true, is now false, and vice-versa.. It's the +-- 'empty' steps which get the true values, and which we end up +-- hearing. + +-- This is clearer if we play a t(3,8) against an inverted f(3,8): +d1 $ stack [struct "t(3,8)" $ sound "kick:4", + struct "f(3,8)" $ sound "snare:4" + ] + +-- You can hear that the snares are 'filling in' where the kicks +-- aren't playing - they never play at the same time. + +-- Filling in patterns like this is a lot of fun, and there's a +-- function called 'stitch' that makes it easier: +d1 $ stitch "t(3,8)" (sound "kick:4") (sound "snare:4") + +-- You only have to give the boolean pattern once, 'stitch' takes care +-- of inverting the pattern for the second pattern. It's called +-- 'stitch', because it's like going up and down to stitch two things +-- together. + +-- You can make more complicated boolean patterns to quickly get some +-- fun patterns going: +d1 $ stitch "t(<3 5>,8,<0 2 3>)" (sound "kick:4") (sound "hc") + +d1 $ stitch "t(<3 5>,<8 8 8 6>,<0 2 4>)" (sound "kick:4") (sound "hc") + +-- Actually it'd be less typing do the stitching _inside_ the sound +-- control pattern: +d1 $ sound (stitch "t(<3 5>,<8 8 8 6>,<0 2 4>)" "kick:4" "hc") + +-- In the above, I only have to write 'sound' once, because the +-- 'stitch' is working on patterns of words, not patterns of sounds. + +-- You can also alternate between patterns of true, and patterns of false +-- values: +drawLine $ struct "(3,8)" "a" + +-- If you prefer you can use '1' or '0' instead of 't' and 'f', the +-- result is exactly the same: +drawLine $ struct "<1 0>(3,8)" "a" + +d1 $ struct "<1 0>(3,8)" $ sound "clap" + +-- You don't have to use the Euclidean syntax, you can just right them +-- out by hand: +d1 $ stitch "t f t t f f t f" (sound "kick:4") (sound "hc") + +-- .. and use the usual mininotation syntax: +d1 $ stitch "t f t [t f]*2 f ~ t f" (sound "kick:4") (sound "hc") + # room 0.2 # sz 0.8 + +-- With stitch, the rhythmic structure comes from the boolean +-- pattern. It has a synonym friend called 'sew', which instead +-- preserves the structure of the patterns it's sewing together. + +-- Lets try it: +d1 $ sew "t f" (sound "kick") (sound "clap:4") + +-- Oh! We only hear the kick. That's because the 'f' only switches to +-- the second pattern for the second half of the cycle, and no new +-- 'clap's happen then. + +-- If we have four claps spread over the cycle, we hear the second two +-- of them: +d1 $ sew "t f" (sound "kick") (sound "clap:4*4") + +-- Sew can be really nice for blending together two more complicated +-- patterns. Lets have a listen to them individually first: + +d1 $ chunk 4 (hurry 2) $ n "0 .. 7" # sound "cpu" + +d1 $ n "0 .. 7" # sound "cpu2" # speed 1.5 # squiz 2 + +-- And now sewn: +d1 $ sew (iter 4 "t f") + (chunk 4 (hurry 2) $ n "0 .. 7" # sound "cpu") + (n "0 .. 7" # sound "cpu2" # speed 1.5 # squiz 2) + +-- In the above I have a really simple "t f" binary pattern, but use +-- 'iter 4' so that it shifts by a quarter every cycle.. So you get +-- different parts of the sewn patterns coming through. + +-- endregion diff --git a/study/nova/disco_punk.tidal b/study/nova/disco_punk.tidal index 36eed34..125fcec 100644 --- a/study/nova/disco_punk.tidal +++ b/study/nova/disco_punk.tidal @@ -1,3 +1,6 @@ +-- Exp #2: Le Disco Punk +-- https://www.youtube.com/watch?v=sNzhxE45mGE + setcps 0.6 d10 -- metronome diff --git a/study/weave.tidal b/study/weave.tidal deleted file mode 100644 index 849252e..0000000 --- a/study/weave.tidal +++ /dev/null @@ -1,6 +0,0 @@ -d1 $ weave 16 (pan sine) - [sound "bd sn cp", - sound "casio casio:1", - sound "[jvbass*2 jvbass:2]/2", - sound "hc*4" - ]