// Lunettatic
// by Les Hall


// global variable
1.0 => float volume;
16::samp => dur clock;
6 => float nps;


// the patch
Gain volumeC => dac;
Gain volumeL => dac.left;
Gain volumeR => dac.right;
volume => volumeL.gain;
volume => volumeR.gain;
volume/2.0 => volumeC.gain;


SqrOsc osc1;
nps => osc1.freq;

CD4040 counter1;
osc1 => counter1.iClock;

LOGIC logic1;
for(int i; i<12; i++)
{
    counter1.oCount[i] => logic1.iInput[i];
}

SUM sum1;
for(int i; i<12; i++)
{
    logic1.oOutput[i] => sum1.iInput[i];
}
sum1.oOutput => LPF antiPop1 => Gain freq1 => SqrOsc osc2 => LPF filter1;
30 => antiPop1.freq;
500 => freq1.gain;
1 => osc2.op;
0.5 => osc2.gain;
250 => filter1.freq;

SPATIAL spatial1;
logic1.oOutput[2] => spatial1.iSelect[0];
logic1.oOutput[3] => spatial1.iSelect[1];
filter1 => spatial1.iSpatial;
spatial1.oSpatialL => volumeL;
spatial1.oSpatialR => volumeR;




SqrOsc osc3;
nps => osc3.freq;

CD4040 counter2;
osc3 => counter2.iClock;

R2R r2r1;
for(int i; i<12; i++)
{
    counter2.oCount[i] => r2r1.iDigital[11-i];
}

r2r1.oAnalog => LPF antiPop2 => Gain freq2 => SqrOsc osc4 => LPF filter2;
30 => antiPop2.freq;
1000 => freq2.gain;
1 => osc4.op;
0.5 => osc4.gain;
500 => filter2.freq;

filter2 => volumeL;




SqrOsc osc5;
nps => osc5.freq;

CD4040 counter3;
osc5 => counter3.iClock;

SUM sum2;
for(int i; i<12; i++)
{
    counter3.oCount[i] => sum2.iInput[i];
}
sum2.oOutput => LPF antiPop3 => Gain freq3 => SqrOsc osc6 => LPF filter3;
30 => antiPop3.freq;
1000 => freq3.gain;
1 => osc2.op;
0.5 => osc6.gain;
500 => filter3.freq;

filter3 => volumeR;




// R2R ladder
class R2R
{
    12 => int max;
    Gain iDigital[max];
    for(int i; i<max; i++)
    {
        iDigital[i] => blackhole;
    }
    Gain oAnalog;
    
    for(int i; i<max; i++)
    {
        Math.pow(2.0, i) / 16384.0 => iDigital[i].gain;
        iDigital[i] => oAnalog;
    }
}




// spatializer
class SPATIAL
{
    Gain iSelect[2];
    for(int i; i<2; i++)
    {
        iSelect[i] => blackhole;
    }
    Gain iSpatial => blackhole;
    Gain oSpatialL;
    Gain oSpatialR;
    
    CD4052 mux;
    
    Gain bitL[4];
    Gain bitR[4];
    
    iSelect[0] => mux.iB;
    iSelect[1] => mux.iA;
    for(int i; i<4; i++)
    {
        iSpatial => bitL[i] => mux.iX[i];
        iSpatial => bitR[i] => mux.iY[i];
        i / 3.0 => bitR[i].gain;
        1.0 - bitR[i].gain() => bitL[i].gain;
    }
    mux.oX => oSpatialL;
    mux.oY => oSpatialR;
}


// analog mux
class CD4052
{
    Gain iA => blackhole;
    Gain iB => blackhole;
    Gain iX[4];
    Gain iY[4];
    for(int i; i<4; i++)
    {
        iX[i] => blackhole;
        iY[i] => blackhole;
    }
    Step oX;
    Step oY;
    
    function void mux()
    {
        while(true)
        {
            if ( (iA.last() < 0.5) & (iB.last() < 0.5) )
            {
                iX[0].last() => oX.next;
                iY[0].last() => oY.next;
            }
            else if ( (iA.last() < 0.5) & (iB.last() > 0.5) )
            {
                iX[1].last() => oX.next;
                iY[1].last() => oY.next;
            }
            else if ( (iA.last() > 0.5) & (iB.last() < 0.5) )
            {
                iX[2].last() => oX.next;
                iY[2].last() => oY.next;
            }
            else if ( (iA.last() > 0.5) & (iB.last() > 0.5) )
            {
                iX[3].last() => oX.next;
                iY[3].last() => oY.next;
            }
            
            clock => now;
        }
    }
    spork ~ mux();
}




// logic network
class LOGIC
{
    12 => int max;
    
    Gain iInput[max];
    for(int i; i<max; i++)
    {
        iInput[i] => blackhole;
    }
    Step oOutput[max];
    
    function void logic()
    {
        int in[max];
        
        while(true)
        {
            for(int i; i<max; i++)
            {
                iInput[i].last() $int => in[i];
            }
            
            (in[0] ^ in[2]) => oOutput[0].next;
            (in[1] ^ in[3]) => oOutput[1].next;
            (in[2] ^ in[4]) => oOutput[2].next;
            (in[3] ^ in[5]) => oOutput[3].next;
            (in[4] ^ in[6]) => oOutput[4].next;
            (in[5] ^ in[7]) => oOutput[5].next;
            (in[6] ^ in[8]) => oOutput[6].next;
            (in[7] ^ in[9]) => oOutput[7].next;
            (in[8] ^ in[10]) => oOutput[8].next;
            (in[9] ^ in[11]) => oOutput[9].next;
            
            clock => now;
        }
    }
    spork ~ logic();
}



// aggregator
class SUM
{
    12 => int max;
    max => int weight;

    Gain iInput[max];
    for(int i; i< max; i++)
    {
        iInput[i] => blackhole;
    }
    Step oOutput;
    
    function void sum()
    {
        while(true)
        {
            0 => float sum;
            for (int i; i<max; i++)
            {
                iInput[i].last() +=> sum;
            }
            sum / weight => oOutput.next;

            clock => now;
        }
    }
    spork ~ sum();
}



// 4040 counter
class CD4040
{
    Gain iClock => blackhole;
    Step oCount[12];
    
    function void counter()
    {
        1<<12 => int max;
        int count;
        int iClockPrev;
        int iClockLast;
        while(true)
        {
            iClockLast => iClockPrev;
            iClock.last() $ int => iClockLast;
            
            if ( (iClockLast > 0.5 ) && (iClockPrev < 0.5) )
            {
                (count + 1) % max => count;
                for(int i; i<12; i++)
                {
                    (count >> i) & 1 => oCount[i].next;
                }
            }
            
            clock => now;
        }
    }
    spork ~ counter();
}


// time loop
while(true)
{
    second => now;
}