Home

Welcome to the Live 4 Bubbles wiki (in construction) !

Parameters for each Track

- Preset Number (red) (state of all the parameters below)

- Line of Tidal Code in Pulsar (blue)

- Tempo (orange)

- Duration (brown)

- Buffer Folder (dark red)

- Sound file within the Buffer Folder (purple)

- Effects (green) (2 combinations)

When ? (40 choices)

• 0 -> No Effect

• 1 -> Every X Cycle (0.9 for at every cycle) -> (every (fmap round (range 10 0 (select t fxt))) (sfxx))

• 2 -> works, but apparently no effect if 0, needs to be 0.05 in the input, even if the scale begins with 1. -> (e. g. whenmod 8 4 - every other block of four loops - Transformation tous les 8 cycles, à chaque bloc de 4) (whenmod 4 (fmap (fromIntegral . round) (range 4 1 (select t fxt))) sfxx)

• 3 -> (whenmod 8 (fmap (fromIntegral . round) (range 8 1 (select t fxt))) sfxx)

• 4 -> (whenmod 16 (fmap (fromIntegral . round) (range 16 1 (select t fxt))) sfxx)

• 5 -> whenT1Inf (realToFrac <$> (sel t fxt)) (sfxx) -> (whenT1Inf tpat f pat = innerJoin $ fmap (\t -> whenT ((< t) . (flip Data.Fixed.mod' 1)) f pat) tpat)

• 6 -> whenT2Inf (realToFrac <$> (sel t fxt)) (sfxx) -> (whenT2Inf tpat f pat = innerJoin $ fmap (\t -> whenT ((< t) . (flip Data.Fixed.mod' 2)) f pat) tpat)

• 7 -> whenT1Sup (realToFrac <$> (sel t fxt)) (sfxx) -> (whenT1Sup tpat f pat = innerJoin $ fmap (\t -> whenT ((> t) . (flip Data.Fixed.mod' 1)) f pat) tpat)

• 8 -> whenT2Sup (realToFrac <$> (sel t fxt)) (sfxx) -> (whenT2Sup tpat f pat = innerJoin $ fmap (\t -> whenT ((> t) . (flip Data.Fixed.mod' 2)) f pat) tpat)

• 9 -> Sometimes X in Cycle -> (sometimesBy (select t fxt) (sfxx))

• 10 -> Sometimes X at each Cycle -> (someCyclesBy (select t fxt) (sfxx))

• 11 -> inside : carries out an peration 'inside' a cycle. What this function is really doing is 'slowing down' the pattern by a given 12 factor, applying the given function to it, and then 'speeding it up' by the same factor. 'inside 2 rev' is like : 'fast 2 $ rev $ slow 2', so the 1st half of a cycle is reversed. -> (inside (fmap (fromIntegral . round) (range 1 16 (select t fxt))) (sfxx))

• 12 -> (inside (fmap (fromIntegral . round) (range 1 32 (select t fxt))) (sfxx))

• 13 -> (inside "<1 2 4 8 16 24 32>" sfxx) -- 6 voire l'effet des séquences qui semblent très intéressants - voire outside, très dependant de la structure puisqu'agit en dehors des cycles

• 14 -> (inside (choose [2,32]) (sfxx))

• 15 -> (inside (irand 32) (sfxx))

• 16 -> (inside (rand * 32) (sfxx))

• 17 -> (inside (wchoose [(2,0.5),(4,0.25),(8,0.25)]) (sfxx)) -- TO DO

• 18 -> (inside (wchoose [(4,0.5),(8,0.25),(16,0.25)]) (sfxx)) -- TO DO

• 19 -> (inside (wchoose [(2,0.5),(8,0.25),(32,0.25)]) (sfxx)) -- TO DO

• 20 -> toWithin (realToFrac <$> max 0.01 (sel t fxt)) (sfxx) -> toWithin tpat f pat = innerJoin $ fmap (\t -> within (0, t) f pat) tpat (the same as 5)

• 21 -> toWithin "<0 0.25 0.5 0.75 1 1 1>" (sfxx)

• 22 -> toWithin (slow 16 saw + 0.1) (sfxx)

• 23 -> toWithin (slow 32 saw + 0.1) (sfxx)

• 24 -> toWithin rand (sfxx)

• 25 -> fromWithin (realToFrac <$> max 0.01 (sel t fxt)) (sfxx) -> fromWithin tpat f pat = innerJoin $ fmap (\t -> within (t, 1) f pat) tpat

• 26 -> fromWithin "<0 0.25 0.5 0.75 0.5 0.25 0>" (sfxx)

• 27 -> fromWithin (slow 16 saw + 0.1) (sfxx)

• 28 -> fromWithin (slow 32 saw + 0.1) (sfxx)

• 29 -> fromWithin rand (sfxx)

• 30 -> The chunk divides a pattern into a given number of parts, then cycles through those parts in turn, applying the given function to each part in turn (one part per cycle). -> chunk 4 (sfxx)

• 31 -> chunk 8 (sfxx)

• 32 -> chunk 16 (sfxx)

• 33 -> chunk (irand 16) (sfxx)

• 34 -> chunk (irand 64) (sfxx)

• 35 -> The chunk' does the same as chunk but cycles through the parts in the reverse direction. -> chunk' 4 (sfxx)

• 36 -> chunk' 8 (sfxx)

• 37 -> chunk' 16 (sfxx)

• 38 -> chunk' (irand 16) (sfxx)

• 39 -> chunk' (irand 64) (sfxx)

How ? (20 choices)

• 0 -> Effect alone

• 1 -> superposition (original sound with its effect) -> The superimpose plays a modified version of a pattern 'on top of' the original pattern, resulting in the modified and original version of the patterns being played at the same time. Implemented with sfux. -> superimpose (# sfx)

• 2 -> superposition with offset -> off is similar to superimpose, in that it applies a function to a pattern, and layers up the results on top of the original pattern. The difference is that off takes an extra pattern being a time (in cycles) to shift the transformed version of the pattern by. -> off 0.125 (# sfx)

• 3 -> superposition with offset -> off 0.25 (# sfx)

• 4 -> superposition with offset -> off 0.33 (# sfx)

• 5 -> superposition with offset at half of a cycle -> off 0.5 (# sfx)

• 6 -> superposition with offset -> off 0.75 (# sfx)

• 7 -> superposition with offset at the next cycle off 1 (# sfx)

• 8 -> superposition with offset at 2 cycles off 2 (# sfx)

• 9 -> superposition with offset off 4 (# sfx)

• 10 -> superposition with offset off "<0.125 0.25 0.5 1>" (# sfx)

• 11 -> superposition with offset off "<0.25 0.75 0.5 0.125>" (# sfx)

• 12 -> superposition with offset off "<0.33 0.25 0.66 0.5>" (# sfx)

• 13 -> jux creates strange stereo effects, by applying a function to a pattern, but only in the right-hand channel. -> jux (# sfx)

• 14 -> juxBy 0.75 (# sfx)

• 15 -> juxBy 0.5 (# sfx)

• 16 -> juxBy 0.25 (# sfx)

• 17 ->. jux (rev . (# sfx))

• 18 -> For example, the following reverses the pattern on the righthand side. -> juxBy 0.75 (rev . (# sfx))

• 19 -> juxBy 0.5 (rev . (# sfx))

• 20 -> juxBy 0.25 (rev . (# sfx))

What ? (X choices)

How much ? (the quantity of the effect)

- Functions on the pattern (blue) (2 combinations)

When ? (40 choices)

How ? (20 choices)

What ? (X choices)

• 1 -> degradeBy allows you to control the percentage of events that are removed. -> degradeBy (realToFrac <$> sel t fuv)

• 2 -> trunc truncates a pattern so that only a fraction of the pattern is played. -> trunc (max 0.005 (sel t fuv))

How much ? (the quantity of the effect)