CtkControl | SuperCollider 3.13.0 Help

Description

Part of the Composer's Tool Kit (CTK) system. See CTK for more details.

CtkControl is a wrapper for a control Bus suitable for use with CTK objects.

Instance Methods

.play(node, argname)

Enable an instance of CtkControl for real-time use

Arguments:

node	target node
argname

.set(val, time: 0.0)

Set the value of CtkControl

Arguments:

val	The value to which the control bus will be set.
time	The time at which to set the control bus. If used in real-time, the time parameter schedules when the change of value should occur. In NRT, schedules the change at time from the value of starttime (or starttime + time)

.free

Returns the bus id to the allocation pool.

.get(action)

Get the value of the bus (asynchronous)

Arguments:

action

The action to be executed when the value is received. The function is passed two parameters: bus index and the actual value

Discussion:

.getn(numChannels, action)

Get the value of the multichannel bus (asynchronous)

Arguments:

numChannels	Number of channels to return; defaults to `this.numChannels`
action	The action to be executed when the value is received. The function is passed two parameters: bus index and an array of actual bus values

Discussion:

.getSynchronous(indexOffset: 0)

Get the value of the bus. This command is synchronous. See Bus help for more information on synchronous access to control buses.

Arguments:

indexOffset

Channel offset into a multichannel CtkControl

Returns:

A single value of the control bus.

NOTE: This method returns a single value, even in the case of a multichannel CtkControl. The indexOffset argument enables reading into other channels of a multichannel CtkControl, e.g. indexOffset: 3 would give you the value of the 4th channel of a multichannel bus.

.getnSynchronous(numChannels, indexOffset: 0)

Get values of a multichannel bus. This command is synchronous. See Bus help for more information on synchronous access to control buses.

Arguments:

numChannels	Number of channels to return; defaults to `this.numChannels`
indexOffset	Channel offset into a multichannel CtkControl

Returns:

An array of values

Discussion:

.high

.high = newhigh

Returns:

the upper bounds value when using *lfo

.low

.low = newlow

Returns:

the lower bounds value when using *lfo

.bus

From superclass: CtkBus

Returns:

bus number (index) of this CtkControl (similar to Bus: -index)

.addTo(aCtkScore)

From superclass: CtkObj

Add this object to a CtkScore

Arguments:

aCtkScore

An instance of CtkScore

Inherited instance methods

Examples

s.boot;
(
var pnotes, group, bus1, bus2, env, freq, control, task;
var cond;
cond = Condition.new;
Routine.run({
    pnotes = CtkProtoNotes(
        SynthDef(\test, {arg dur, freq, amp;
            var env, envgen, src;
            env = Control.names([\env]).kr(Env.newClear(8));
            envgen = EnvGen.kr(env, timeScale: dur, doneAction: 2);
            src = SinOsc.ar(freq, 0, amp * envgen);
            Out.ar(0, Pan2.ar(src, Rand(-1.0, 1.0)));
        }),
        SynthDef(\control, {arg outbus, rate, low, hi;
            Out.kr(outbus, LFNoise2.kr(rate).range(low, hi))
        }),
        SynthDef(\controlenv, {arg gate = 1, outbus;
            var env;
            env = Control.names([\env]).kr(Env.newClear(8));
            Out.kr(outbus, EnvGen.kr(env, gate));
        }).load(s)
    );

s.sync(cond);

group = CtkGroup.play;
    bus1 = CtkControl.play; // create a CtkControl for writing out to
    bus2 = CtkControl.play; // create a CtkControl for writing out to

env = Env([0, 1, 0], [1, 4], [3, -4], 1);

// create a controlenv and a loop of CtkNotes to play inside the CtkGroup
    freq = pnotes[\control].note(addAction: \head, target: group)
    .outbus_(bus1) // need to use the .bus method on CtkControl to just pass in its bus id
    .rate_(1)
    .low_(100)
    .hi_(1050)
    .play;

control = pnotes[\controlenv].note(addAction: \head, target: group)
    .outbus_(bus2) // need to use the .bus method on CtkControl to just pass in its bus id
    .env_(env)
    .play;

task = Task({
        var reltime, dur;
        reltime = env.releaseTime;
        dur = 10;
        // schedule the release of the global envelope
        SystemClock.sched(dur - reltime, {
            group.release;
        });
        // schedule the release of the Task
        SystemClock.sched(dur, {
            group.freeAll;
            task.stop;
        });
        loop({
            pnotes[\test].note(addAction: \tail, target: group)
            .dur_(1)
            .env_(Env([0, 1, 0], [0.5, 0.5], \sin))
            .freq_(bus1) // if a CtkControl is passed in, the arg will be mapped to the
            .amp_(bus2) // CtkControls bus
            .play;
            0.5.wait;
        })
    });

task.play;
})
)

Real-time uses

Examples that set the value of the CtkControl in real-time, and take advantage of SynthDef's lag controls.s.boot; ( a = CtkNoteObject( SynthDef(\test, {arg freq = 440, amp = 0; Out.ar(0, Pan2.ar(SinOsc.ar(freq, 0, amp), LFNoise2.kr(0.3))) }, [2, 1]) ); b = CtkControl.play(initVal: 440); c = CtkControl.play(initVal: 0); ) // create a new instance, and map the freq and amp parameters to the CtkControls d = a.note.freq_(b).amp_(c).play; c.set(0.4); b.set(660); // unmap the control d.freq_(440); // remap it d.freq_(b); // set the amp to 0.0 c.set(0.0); // kill the node d.free;

CtkScore uses

Examples that populate an instance of CtkScore. The CtkScore can then be rendered in NRT, played or saved as a file. See CtkScore for more examples.( var scpn, score, grainfun, gliss; scpn = CtkProtoNotes( SynthDef(\control, {arg outbus, rate, low, hi; Out.kr(outbus, LFNoise2.kr(rate).range(low, hi)) }), SynthDef(\test, {arg freq, amp, dur; var env, envgen, src; env = Env([0, 1, 0], [0.5, 0.5], \sin); envgen = EnvGen.kr(env, timeScale: dur); src = BPF.ar(WhiteNoise.ar(amp), freq, 0.01, amp * envgen); Out.ar(0, Pan2.ar(src, Rand(-1.0, 1.0))); }) ); score = CtkScore.new; /* creates a granular gesture of duration. Each grain is 0.1 seconds long, new grain every 0.02 seconds */ grainfun = {arg starttime, duration, ampenv, lowfreq, hifreq; var now, note; now = 0; ampenv.times = ampenv.times.normalizeSum * duration; // scale the Env's time to the gestures while({ // create a note... add it to the CtkScore note = scpn[\test].note(starttime + now, 0.1) .freq_(lowfreq.rrand(hifreq)) .amp_(ampenv[now]) .dur_(0.1); score.add(note); // tell CtkScore to add the note now = now + 0.02; now < duration; }); }; gliss = {arg starttime, duration, rate, lowfreq, hifreq; var cbus, control, note, group; cbus = CtkControl.new; // run these processes within its own CtkGroup group = CtkGroup.new(addAction: \head, target: 1).addTo(score); control = scpn[\control].new(starttime, duration, \head, group) .outbus_(cbus) .rate_(rate) .low_(lowfreq) .hi_(hifreq) .addTo(score); // tell CtkNote to add to a CtkScore note = scpn[\test].new(starttime, duration, \tail, group) .freq_(cbus) .amp_(2) .dur_(duration) .addTo(score); }; grainfun.value(1, 10, Env([0, 1, 0], [0.5, 0.5], [3, -5]), 440, 880); grainfun.value(4, 4, Env([0, 1, 0], [0.5, 0.5], [3, -5]), 4400, 8800); grainfun.value(6, 12, Env([0, 1, 0], [0.5, 0.5], [3, -5]), 300, 400); grainfun.value(3, 10, Env([0, 1, 0], [0.5, 0.5], [3, -5]), 200, 200); grainfun.value(1.5, 20, Env([0, 1, 0], [0.5, 0.5], [3, -5]), 7000, 7100); 5.do({arg i; var j; j = i + 1; gliss.value(3 + (i + 4), 10.rrand(7), j.reciprocal, 440 * j, 880 * j); }); // uncomment to play the CtkScore you have created score.play(s); // uncomment to write the score to a soundfile //score.write("~/Desktop/test.aiff".standardizePath, 22, // options: ServerOptions.new.numOutputBusChannels_(2)); // uncomment to save the CtkScore as a file //score.saveToFile("~/Desktop/test.sc".standardizePath); )

Env and LFO Uses

helpfile source: /Library/Application Support/SuperCollider/downloaded-quarks/Ctk/HelpSource/Classes/CtkControl.schelp
link::Classes/CtkControl::

numChans	The number of channels to allocate.
initVal	Initial value to set the bus to.
starttime	Start time, useful in CtkScore
bus	The bus index to use (optional). Normally you don't need to specify it, as it will be allocated for you.
server	An instance of Server to allocate this bus on. Defaults to Server.default.

numChans	The number of channels to allocate.
initVal	Initial value to set the bus to.
bus	The bus index to use (optional). Normally you don't need to specify it, as it will be allocated for you.
server	An instance of Server to allocate this bus on. Defaults to Server.default.

env	An instance of an Env to be passed to a synth as the argument for an EnvGen.
starttime	If used in a CtkScore, specifies a time to write the initVal to the bus.
addAction	A symbol (\head, \tail, \before, \after or \replace) or an addAction id (see Server Command Reference: /s_new for a more in-depth description)
target	A node ID (synth or group) or an instance of CtkGroup or CtkNote.
bus	The bus index to use (optional). Normally you don't need to specify it, as it will be allocated for you.
server	An instance of Server to allocate this bus on. Defaults to Server.default.
levelScale	The levelScale argument to be supplied to EnvGen.
levelBias	The levelBias argument to be supplied to EnvGen.
timeScale	The timeScale argument to be supplied to EnvGen.
doneAction	The doneAction argument to be supplied to EnvGen. See Done: Actions for more information.

ugen	An oscillating Ugen. Choose from: LFNoise0, LFNoise1, LFNoise2,SinOsc, Impulse, LFSaw, LFPar, LFTri, LFCub.
freq	The frequency of oscillation.
low	The lower bounds of oscillation.
high	The upper bounds of oscillation.
phase	The starting phase of the oscillator.
starttime	If used in a CtkScore, specifies a time to write the initVal to the bus.
duration	Specifies duration (for CtkScore use).
addAction	A symbol (\head, \tail, \before, \after or \replace) or an addAction id (see Server Command Reference: /s_new for a more in-depth description)
target	A node ID (synth or group) or an instance of CtkGroup or CtkNote.
bus	The bus index to use (optional). Normally you don't need to specify it, as it will be allocated for you.
server

CtkControl : CtkBus : CtkObj : Object Extension

CtkControl.new(numChans: 1, initVal: 0.0, starttime: 0.0, bus, server)

Arguments:

Returns:

CtkControl.play(numChans: 1, initVal: 0.0, bus, server)

Arguments:

Returns:

CtkControl.env(env, starttime: 0.0, addAction: 0, target: 1, bus, server, levelScale: 1, levelBias: 0, timeScale: 1, doneAction: 0)

Arguments:

Returns:

Discussion:

CtkControl.lfo(ugen, freq: 1, low: -1, high: 1, phase: 0, starttime: 0.0, duration, addAction: 0, target: 1, bus, server)

Arguments:

Returns:

Discussion:

.play(node, argname)

Arguments:

.set(val, time: 0.0)

Arguments:

.free

.get(action)

Arguments:

Discussion:

.getn(numChannels, action)

Arguments:

Discussion:

.getSynchronous(indexOffset: 0)

Arguments:

Returns:

.getnSynchronous(numChannels, indexOffset: 0)

Arguments:

Returns:

Discussion:

.high

.high = newhigh

Returns:

.low

.low = newlow

Returns:

.bus

Returns:

.addTo(aCtkScore)

Arguments:

CtkControl : CtkBus : CtkObj : Object
Extension