One for All: Difference between revisions

Rough multitrack recording by Jacob Barton, http://oneforall.ytmnd.com

Code tutorial (with assignment for xenharmonic campers) in ChucK (save as a .ck file to use in ChucK):

<nowiki>/* Sagittal Songbook 01

A four-part round in just intonation, in 11/4 time

Coded by xenjacob Jan. 2020

The implementation is basic, and shared in this way both to introduce

degree of 'grunt work' which may (not must) accompany any work of art.

ASSIGNMENT FOR XENCAMPERS:

2. Try modifying 1/1 pitch and/or tempo (read thru the comments below for how)

'more musical', and send it to xenjacob. No need to know how to code it yourself.

The melody line is first encoded as a 2D array corresponding

to pitch and rhythm values

 

This kind of score entry is labor-intensive, but a rather good match to the

Sagittal Songbook project due to the brevity of most of the songs.

 

Pitches are in JI intervals in relation to the defined 1/1 (notated C)

A decimal point in the fraction forces ChucK to do non-integer

arithmetic to create a floating-point value (otherwise it will e.g. compute

4/3 as 1 remainder 1 and discard the remainder)

 

Rhythms are declared in relation to the value of a quarter note,

assigned here to the value 1 (half note = 2, dotted half = 3, etc.)

 

[ 3/2., 2 ], // things

[ 2/1., 1 ], // wing-

[ 7/4., 1], // -ed

[ 3/2., 1 ], // are

[ 4/3., 2 ], // made

[ 3/2., 2 ], // jump-

[ 2/1., 2 ], // -ing

[ 5/2., 1 ], // in-

[ 9/4., 1 ], // -to

[ 2/1., 1 ], // the

[ 7/4., 1 ], // sky__

[ 7/4., 2 ], // (bend)

[ 2/1., 5/3. ], // ____.

// implementing a rhythmic breath or 'hiccup' at the end of each phrase

// equal to two-thirds of a beat.

 

[ 5/4., 2 ], // Fall-

[ 5/4., 2 ], // -ing

[ 4/3., 1 ], // brings

[ 9/8., 1 ], // no

[ 5/4., 1 ], // di-

[ 2/1., 2 ], // -sas-

[ 7/4., 2 ], // -ter

[ 15/8., 2 ], // when

[ 5/4., 2 ], // you

[ 3/2., 3 ], // can

[ 4/3., 1 ], // fly_

[ 4/3., 2 ], // (bend)

[ 5/4., 5/3. ], // __.

 

[ 3/2., 2 ], // Calls

[ 2/1., 2 ], // sing

[ 3/2., 3 ], // birds

[ 9/8., 2 ], // to

[ 1/1., 2 ], // each

[ 9/8., 1 ], // o-

[ 5/4., 1 ], // -ther

[ 11/8., 1 ], // but

[ 3/2., 1], // who

[ 2/1., 3 ], // knows

[ 9/4., 1 ], // why?__

[ 9/4., 2 ], // __(bend)

[ 2/1., 5/3.], // ___

 

[ 2/1., 4], // Fly-

[ 7/4., 3 ], // -ing

[ 4/3., 2 ], // looks

[ 3/2., 2 ], // fun;

[ 3/2., 4 ], // I'm

[ 1/1., 1 ], // will-

[ 9/8., 1 ], // -ing

[ 5/4., 1 ], // to

[ 1/1., 4.+2/3. ] // try.

 

] @=> float score[][]; // "@=>" is the assignment operator for arrays.

 

// Since there are only a few glissandi in the score,

// let's collect the index #'s of the notes which gliss

// into an array "bends":

 

[ 13, 26, 39 ] @=> int bends[];

 

// one_one will define the 1/1 frequency in Hz

// **CHANGE THIS** to try in different keys!

// 261.6 is approximately concert C pitch

// 240 tunes to electrical hum (in the Americas and Asia anyway)

// B flat (233) has also been traditionally used in this round.

 

// 'pulse' wil define the time duration of a quarter note

// **CHANGE THIS** to try different tempi!

// the :: must separate the numerical value and the duration unit

// (which can be samp, ms, second, minute, hour, day, or week)

 

// PlayScore is a function which will read the score (any score specified

// in the same manner, actually), note by note, into

// a dedicated triangle wave oscillator.

 

// But Wait!

// Musicality Mod 1 (suggested by Thomas): the ability to play in other registers.

// PlayScore will take an additional argument, specifying the number of  

// octaves offset (-1 for octave down, 0 for at pitch, 1 for octave up, etc.

    TriOsc t => dac; // direct link to the digital audio converter (soundcard)

    0.25 => t.gain; // range [0,1] - let's leave room for 4 voices here

    // (digital distortion otherwise...which actually makes some really neat effects, try it!

    // loop iterates thru the play array, one note entry at a time

        // read the array, change the frequency

        play[i][0] * one_one * Math.pow(2, octave_shift) => t.freq;

        // glissando code

        // hard-coded to 3 total glisses, because ChucK doesn't

        if( bends[0] == i || bends[1] == i || bends[2] == i )

        {

            // divides the length of the rhythm of that note

            // into 366 parts, because, hey, leap year!

            for( 0 => int j; j <= rhdiv; j++)

            {

                // one_one * play[i][0] *

                //  Math.pow( (play[i+1][0]/play[i][0]) , j/rhdiv ) => t.freq;

                // Above code divides the glissando down by equal (logarithmic) steps,

                // Doesn't sound 'natural' to me,

                // Let's try equal-frequency steps:

                ((play[i+1][0] - play[i][0])*one_one/rhdiv*j + play[i][0]*one_one) * Math.pow(2, octave_shift) => t.freq;

                 pulse*play[i][1]/rhdiv => now;

                // I still wasn't happy with it,

            }

        }

            // chucking a duration to now advances time

            // by that amount within the shred

            pulse*play[i][1] => now;

 

PlayScore( score, 0); // Calling the function once will play thru the melody once.

// See if you can add multiple shreds of this at just the right time to play in round!

// remove lines 169 and 205, AND comment/remove line 165, to unlock...

// CHAPTER TWO - Programmed Polyphony

// a function to hang out between successive entries

fun void waitLine() {

    (22.+2/3.)*pulse => now;

}

// to execute functions 'in series', simply call them, as  

// to execute 'in parallel', use 'spork~' to create breakoff shreds.

// 'spork a shred' > 'fork a thread', good one Ge Wang...

 

// the below code initiates five separate shreds

// to simulate five round entries

 

spork~ PlayScore ( score, 0 ); // first entry

waitLine();

spork~ PlayScore ( score, 1 );

waitLine();

spork~ PlayScore ( score, 0 );

waitLine();

spork~ PlayScore ( score, 1 );

waitLine();

// now check this out

// for the last entry, we gonna do a 'Meno Mosso' (slower tempo)

// we change ONE VARIABLE, and all four lines follow!

// if we had passed the pulse as an argument to each function instead of

// using this sort of global variable, this wouldn't work.

1.1 *=> pulse; // multiply value of pulse by 1.1 and re-assign

spork~ PlayScore ( score, 0 ); // final entry

// now, let the round play out;

// if the main shred of this script terminated early,

// it would automatically terminate any child shreds still running

waitLine();

waitLine();

waitLine();

waitLine();

/*</nowiki>