SuperCollider CLASSES (extension)

Space

A spatial tool for Ndefs
Inherits from: Radicles : Object

Description

A tool for automatially spatialising Ndefs.

Class Methods

*new (ndefArr, system: 'pan2', panArr, chanNum: 2, play: true, fadeTime)

Create a new Space to spatialise Ndefs.

Arguments:

ndefArr

An array of mono Ndef's to be spatialised.

system

Spatial system.

panArr

Number of channels.

chanNum

An array of panning values.

play

Ndef fadeTime.

Inherited class methods

Instance Methods

-set ( ... args)

Arguments:

.

Array of Ndefs to be outputed by system

(arg2)

Array of panning values

Inherited instance methods

Undocumented instance methods

-arrPan

-clear

-define (ndefArr, panArr, play: true, fadeTime)

-fadeTime (index, time)

-initSpace (ndefArr, system, panArr, chanNum, play, fadeTime)

-inputArr

-ndefs

-numChannels

-object

-object = value

-objectFile

-objectFile = value

-play

-redefine (ndefArr, system: 'pan2', panArr, chanNum: 2, play: true)

-setn ( ... args)

-xset ( ... args)

-xsetn ( ... args)

Examples

s.boot;

(
Ndef(\x, {SinOsc.ar(440,0,0.1)});
Ndef(\y, {SinOsc.ar(880,0,0.1)});
~arr = [Ndef(\x), Ndef(\y)];
)

n = Space(~arr, \pan2, [-1,1], fadeTime: 1);

n.numChannels; //number of channels

n.xset(\pan, Array.panDis(~arr.size, ~arr.size).scramble.postln); //evaluate several times



a = SpecFile.read(\space, \pan);

~node1 = ModMap.map(n.ndefs[0], \pan, \sin, a, [\freq, 1]);

~node2 = ModMap.map(n.ndefs[1], \pan, \sin, a, [\freq, 0.1]);

n.ndefs

Ndef(\z, {Impulse.ar(5)}).ar(1);

~arr = ~arr.add(Ndef(\z));

n.define(~arr, Array.panDis(~arr.size, rrand(~arr.size, ~arr.size*3)).scramble.postln);

Ndef(\x, {Impulse.ar(3)});
Ndef(\y, {Impulse.ar(7)});

[\z,\x,\y].do{|i| Ndef(i, {});};

[\z,\x,\y].do{|it,ind| Ndef(it, {SinOsc.ar(220*(ind+1),0,0.1)});}


a = Array.interpolation(~arr.size,-0.5,0.5).clump(~arr.size/2);
a.do({|item| b = b.add(item.reverse) });
~panArr = [Array.panDis(~arr.size, ~arr.size)*pi, b.flat * pi].flop;

n.redefine(~arr, \panB, ~panArr, 4); //start a new system

n.redefine(~arr, \panB, ~panArr, 8); //start a new system

n.redefine(~arr, \pan2);

n.numChannels;


Ndef.clear(6);

/////////////////////////////////////

s.boot;

Ndef(\x, {SinOsc.ar(440,0,0.2)*0.2});
Ndef(\y, {SinOsc.ar(880,0,0.2)*0.2});

~arr = [Ndef(\x), Ndef(\y)];

a = Array.interpolation(~arr.size,-0.5,0.5).clump(~arr.size/2);
a.do({|item| b = b.add(item.reverse) });
~panArr = [Array.panDis(~arr.size, ~arr.size)*pi, b.flat * pi].flop;

n = Space(~arr, \panB, ~panArr, 4, fadeTime: 2);

n.numChannels;

n.xset(0, \pan0, -0.3);

n.fadeTime(\all, 2); //set fadeTime for space class
n.fadeTime; //print fadeTimes

n.xsetn(\pan0, [-0.5pi,0.5pi], \pan1, [-0.25pi,0.25pi]); //pairs of arg settings: azimuth, elevation

n.xsetn(\pan0, [0.75pi, -0.75pi], \pan1, [0,0]); //azimuth, elevation

n.xsetn(\pan0, [-pi,pi], \pan1, [-0.5pi,0.5pi]); //azimuth, elevation

n.xsetn(\pan0, [0.5pi,-0.5pi], \pan1, [0.25pi, -0.25pi]); //azimuth, elevation


Ndef.clear(1);

/////////////////////////////////////

s.boot;

Ndef(\x, {SinOsc.ar(440,0,0.2)*0.2});
Ndef(\y, {SinOsc.ar(880,0,0.2)*0.2});

~arr = [Ndef(\x), Ndef(\y)];

~chanNum = 6;
n = Space(~arr, \split, [1,3], ~chanNum);

n.numChannels;

n.fadeTime(\all, 2);

n.xset(\pan, [0,2]);

n.xset(\pan, [1,3]);

n.define(Array.fill(~chanNum, {~arr.choose.postln}), (0..(~chanNum-1)));

n.ndefs.do{|item| item.clear };

~chanNum = 8;
n = Space(Array.fill(8, {~arr.choose.postln}), \split, (0..(~chanNum-1)), ~chanNum);

Ndef.all.do(_.fadeTime = 0);

n.set(\pan, (0..(~chanNum-1)).scramble.postln);


Ndef.clear;