BBCPPermute | SuperCollider 3.13.0 Help

Description

A relatively straight forward cut procedure supporting arbitrary user defined permutation of equally divided chunks of the target.

Class Methods

.new

Create a BBCPPermute object with the given parameters.

Arguments:

phraselength	Choose a new phraselength. You can pass a function, which will be called at each new phrase. Normally this would be equal to the size in beats of the source to be cut (assuming some fixed signal buffer, sound file)
subdivfunc	A function returning the number of equally spaced divisions in which to split a new phrase. The new currphraselength is passed as an argument to your function.
permutefunc	Some mapping function which permutes the normal playback order of slices. If it returned the index passed in, there would be no swapping of chunks of the sample around. Your arbitrary permutation function is passed the index to permute, the current number of subdivisions for the phrase, and the current position in the phrase. If you return values out of range, they'll be put into range for you.
stutterfunc	A function returning the number of subdivisions for the next block. The default is one, giving no stuttering. Arguments passed in are the index, the subdivisions , and the position in beats in the current phrase.

Instance Methods

.initBBCPPermute

Called internally after a new.

Other methods are overrides of BBCutProc base class behaviour. BBCPPermute will flag a roll when stuttering.

Examples

//you must have run this line before any of the examples below
f= BBCutBuffer(Platform.resourceDir +/+ "sounds/break.aiff",8);

TempoClock.default.tempo_(2.3);

//default, getting back what you put in
a=BBCut2(CutBuf1(f),BBCPPermute(8.0)).play;

a.end;

//default, getting back what you put in, give or take some enveloping
a=BBCut2(CutBuf2(f),BBCPPermute(8.0)).play;

a.pause
a.resume
a.stop;
a.free;

//reverse slices, 16 slices over 8 beat sample= eighth note (0.5 beat) slices

a=BBCut2(CutBuf1(f),BBCPPermute.new(8.0, 16, {arg index, n;  n-index-1})).play(ExternalClock(TempoClock(2.5)).play);

a.end

(   //swap strong and weak, with occasional stuttering every fourth block

BBCut2(CutBuf2(f),
BBCPPermute.new(
8.0,    //phrase length same as sample length
16,     //cut in eight notes- 8.0/16= 0.5...
{arg index, n;  if(index%2==0,{index+1},{index-1})},    //swap strong and weak
{arg index; if((index==4) || (index==7), 3, 1)}
)).play
)

(   //more random happenings
var mult;

BBCut2(CutBuf2(f),
BBCPPermute.new(
{mult= [4.31, 1.29, {rrand(5.01, 10.09)}].choose.value;  8.0}, //this is called beginning of every phrase, so use the opportunity to select a new multiplier
{[8, 16, 32].choose},
{arg index, n;  index*mult},
{if(0.05.coin,{rrand(2,5)},1)}
)).play;
)

(   //granular mess
var sf, pitch, when, now, duty;
var bbcs, bbcp, bbcutter;

Routine.run({

SynthDef(\fx, {ReplaceOut.ar(0,Limiter.ar(0.1*CombN.ar(In.ar(0, 2),0.3,SinOsc.kr(0.05, 0, 0.125, 0.15), SinOsc.kr(0.023, 0, 0.5, 0.6))))  }).send(s);

sf= BBCutBuffer("sounds/a11wlk01.wav",4);

s.sync;

pitch=1.0;
when= 0;
now=0;

bbcs= [
CutBuf2(sf,
pbsfunc: { if(now>=when,{pitch= ([0.125, 1, 1.05].choose)+ (0.05.rand2)}); pitch+(0.01.rand2)},
dutycycle:{ if(now>=when, {now=0; when= 300.rand; duty= rrand(0.2,10.0)*(rrand(0.5,1.0))}); now=now+1; duty}
),
CutMixer(0,1.0,1.0,{1.0.rand2}),
CutBRF1.new
];

bbcp=BBCPPermute.new(
{rrand(1.0,10.0)*(rrand(0.5, 1.0))}, //weird phrase lengths only
{rrand(1, 7)*8-1}, //subdivisions always odd
{arg index, n;  (2.7*n*n*index)+(12.2.rand2)},
{if(0.35.coin,{rrand(2,5)},1)}
);

bbcutter= BBCut2(bbcs,bbcp).play(2.4);

Synth.tail(Node.basicNew(s,1),"fx");

});

)

//ui controlling rotation and inversion of slices - ie, move within a rhythmic set class
//break2 is reference
(
var w, rotate, invert, currrot, currinv;
var sf, clock;

clock=ExternalClock(2.3).play;

w = SCWindow("BBCPPermute demo N.M.Collins 5/08/05", Rect(100, 100, 200, 100));

rotate= SCSlider(w, Rect(0,0,100,30), "rotation");
invert= SCButton(w, Rect(0,50,100,30), "invert");

invert.states= [["invert"],["revert"]];
rotate.action_({currrot= rotate.value;});
invert.action_({currinv= invert.value;});

currrot=0.0;currinv=0.0;

w.front;

Routine.run({
var cutter1, cutter2;

sf= BBCutBuffer.array([Platform.resourceDir +/+ "sounds/break.aiff",Platform.resourceDir +/+ "sounds/break2.aiff"],[8,4]);

s.sync;

cutter1= BBCut2([CutBuf2(sf.at(0)),CutMixer(0,0.5,1.0,-1.0)],BBCPPermute.new(
8.0,16,{arg i,n;
var t;
t=i+((currrot*16-0.001).asInteger);

if((currinv)>0.1, {t= n-t-1});

t%n;
}
));

//reference break
cutter2= BBCut2([CutBuf2(sf.at(1)),CutMixer(0,0.3,1.0,1.0)],BBCPPermute.new);

cutter1.play(clock);
cutter2.play(clock);

});

)

//live coding of new permutation functions as you go along
(
~permutefunc={arg i,n; i%n};

BBCut2(CutBuf2(f),BBCPPermute(8.0, 16, {arg i,n; ~permutefunc.value(i,n)})).play(2.7);
)

//now change the permutation function as desired
~permutefunc= {arg i,n; (((i+5).rand)**(i.min(7)))%n};

~permutefunc= {arg i,n; ((i+(i.rand))*(rrand(2,i)))%n};

helpfile source: HelpSource/Classes/BBCPPermute.schelp
link::BBCut/Classes/BBCPPermute::

BBCPPermuteExtension