void play(double *output) {
//so this first bit is just a basic metronome so we can hear what we're doing.
currentCount=(int)timer.phasor(0.5);//this sets up a metronome that ticks every 2 seconds
if (lastCount!=currentCount) {//if we have a new timer int this sample, play the sound
ADSR.trigger=1;
cout << "tick\n";//the clock ticks
lastCount=0;//set lastCount to 0
}
//and this is where we build the synth
ADSRout=ADSR.adsr(1.0,ADSR.trigger);
LFO1out=LFO1.sinebuf(0.2);//this lfo is a sinewave at 0.2 hz
VCO1out=VCO1.pulse(55,0.6);//here's VCO1. it's a pulse wave at 55 hz, with a pulse width of 0.6
VCO2out=VCO2.pulse(110+LFO1out,0.2);//here's VCO2. it's a pulse wave at 110hz with LFO modulation on the frequency, and width of 0.2
VCFout=VCF.lores((VCO1out+VCO2out)*0.5, ADSRout*10000, 10);//now we stick the VCO's into the VCF, using the ADSR as the filter cutoff
double finalSound=VCFout*ADSRout;//finally we add the ADSR as an amplitude modulator
ADSR.trigger=0;
output[0]=finalSound;
output[1]=finalSound;
}
void play(double *output) {
CurrentCount=myCounter.phasor(1, 1, 9);//phasor can take three arguments; frequency, start value and end value.
if (CurrentCount<5)//simple if statement
myOscOutput=mySwitchableOsc.square(CurrentCount*100);
else if (CurrentCount>=5)//and the 'else' bit.
myOscOutput=mySwitchableOsc.saw(CurrentCount*50);//one osc object can produce whichever waveform you want.
if (CurrentCount==1)
myEnvelope.trigger(0,myEnvelopeData[0]); //trigger the envelope
myFilteredOutput=myFilter.lores(myOscOutput,(myEnvelope.line(6, myEnvelopeData)),10);//lores takes an audio input, a frequency and a resonance factor (1-100)
myPanPosition=myAutoPanner.sinewave(1);
myOutputs.stereo(myFilteredOutput,myStereoOutput,myPanPosition);//Stereo, Quad or 8 Channel. Specify the input to be mixed, the output[numberofchannels], and the pan (0-1,equal power).
output[0]=myStereoOutput[0];//When working with mixing, you need to specify the outputs explicityly
output[1]=myStereoOutput[1];//
}
void play(double *output) {
myOutputs.stereo(myOsc.noise(),myStereoOutput,(myAutoPanner.sinewave(1)+1)/2);//Stereo, Quad or 8 Channel. Specify the input to be mixed, the output[numberofchannels], and the pan (0-1,equal power).
output[0]=myStereoOutput[0];//When working with mixing, you need to specify the outputs explicitly
output[1]=myStereoOutput[1];//
}
void play(double *output) {
//Using the phasor we can create a ramp, and use this ramp to set the frequency of one of the waves.
//When the frequency of the lower waveform passes over the threshold of 20hz, we start to hear two new waveforms.
//The frequency of the first new wave is the sum of the two original waves.
//The frequency of the second new wave is the difference of the two original waves.
//So you hear two new waves, one going up, one going down.
output[0]=mySine.sinewave(440)*myOtherSine.sinewave(myPhasor.phasor(0.01,0,440));
output[1]=output[0];
}
void play(double *output) {
// A pulse wave!!! Yay
out = osc.pulse(90, ramp.phasor(.2));
// Fill our output buffer
output[0]=out;
output[1]=out;
// After we have filled our output array, send the array
// and the size of the array (in this case the amount of
// channels, but in ofx or juce you might need to do
// something like channels*bufferSize).
recorder.passData(output, maxiSettings::channels);
}
void play(double *output) {
CurrentCount=myCounter.phasor(1*((another.sawn(0.1)+1)/2), 1, 9);//phasor can take three arguments; frequency, start value and end value.
if (CurrentCount<5) {//simple if statement
myOscOutput=mySwitchableOsc.square(myArray[CurrentCount]);
}
else if (CurrentCount>=5) {//and the 'else' bit.
myOscOutput=mySwitchableOsc.sawn(myArray[CurrentCount]);//one osc object can produce whichever waveform you want.
}
output[0]=myOscOutput;//point me at your speakers and fire.
output[1]=output[0];
}
void play(double *output) {
CurrentCount=myCounter.phasor(1, 1, 9);//phasor can take three arguments; frequency, start value and end value.
// here we use a conditional to make something happen at a specific time.
if (CurrentCount<5)//simple if statement
myOscOutput=mySwitchableOsc.square(CurrentCount*100);
else if (CurrentCount>=5)//and the 'else' bit.
myOscOutput=mySwitchableOsc.sinewave(CurrentCount*50);//one osc object can produce whichever waveform you want.
output[0]=myOscOutput;
output[1]=output[0];
}
void play(double *output) {
myCurrentVolume=myEnvelope.line(4,myEnvelopeData);
CurrentCount=myCounter.phasor(1, 1, 9);//phasor can take three arguments; frequency, start value and end value.
if (CurrentCount<5)//simple if statement
myOscOutput=mySwitchableOsc.square(CurrentCount*100);
else if (CurrentCount>=5)//and the 'else' bit.
myOscOutput=mySwitchableOsc.sinewave(CurrentCount*50);//one osc object can produce whichever waveform you want.
if (CurrentCount==1)
myEnvelope.trigger(0,myEnvelopeData[0]); //trigger the envelope
*output=myOscOutput*myCurrentVolume;//point me at your speakers and fire.
}
void play(double *output) {//this is where the magic happens. Very slow magic.
currentCount=(int)timer.phasor(9);//this sets up a metronome that ticks every so often
if (lastCount!=currentCount) {//if we have a new timer int this sample, play the sound
trigger=1;//play the arpeggiator line
trigger2=leadLineTrigger[playHead%256];//play the lead line
if (trigger2==1) {//if we are going to play a note
leadPitch=mtof.mtof(leadLinePitch[newnote]);//get the next pitch val
newnote++;//and iterate
if (newnote>14) {
newnote=0;//make sure we don't go over the edge of the array
}
}
currentPitch=mtof.mtof(pitch[(playHead%4)]+chord[currentChord%8]);//write the frequency val into currentPitch
playHead++;//iterate the playhead
if (playHead%32==0) {//wrap every 4 bars
currentChord++;//change the chord
}
//cout << "tick\n";//the clock ticks
lastCount=0;//set lastCount to 0
}
bassout=filter2.lores(envelope.adsr(bass.saw(currentPitch*0.5)+sound.pulse(currentPitch*0.5,mod.phasor(1)),1,0.9995, 0.25, 0.9995, 1, trigger),9250,2);//new, simple ADSR.
leadout=filter.lores(leadenvelope.ar(lead2.saw(leadPitch*4)+lead.pulse(leadPitch+(leadmod.sinebuf(1.9)*1.5), 0.6), 0.00005, 0.999975, 50000, trigger2),5900,10);//leadline
delayout=(leadout+(delay.dl(leadout, 14000, 0.8)*0.5))/2;//add some delay
if(trigger!=0)trigger=0;//set the trigger to off if you want it to trigger immediately next time.
output[0]=(bassout+delayout)/2;//sum output
output[1]=(bassout+delayout)/2;
}
void play(double *output) {
mix=0;//we're adding up the samples each update and it makes sense to clear them each time first.
//so this first bit is just a basic metronome so we can hear what we're doing.
currentCount=(int)timer.phasor(8);//this sets up a metronome that ticks 8 times a second
if (lastCount!=currentCount) {//if we have a new timer int this sample, play the sound
if (voice==6) {
voice=0;
}
ADSR[voice].trigger=1;//trigger the envelope from the start
pitch[voice]=voice+1;
voice++;
}
//and this is where we build the synth
for (int i=0; i<6; i++) {
ADSRout[i]=ADSR[i].adsr(1.,ADSR[i].trigger);//our ADSR env is passed a constant signal of 1 to generate the transient.
LFO1out[i]=LFO1[i].sinebuf(0.2);//this lfo is a sinewave at 0.2 hz
VCO1out[i]=VCO1[i].pulse(55*pitch[i],0.6);//here's VCO1. it's a pulse wave at 55 hz, with a pulse width of 0.6
VCO2out[i]=VCO2[i].pulse((110*pitch[i])+LFO1out[i],0.2);//here's VCO2. it's a pulse wave at 110hz with LFO modulation on the frequency, and width of 0.2
VCFout[i]=VCF[i].lores((VCO1out[i]+VCO2out[i])*0.5, 250+((pitch[i]+LFO1out[i])*1000), 10);//now we stick the VCO's into the VCF, using the ADSR as the filter cutoff
mix+=VCFout[i]*ADSRout[i]/6;//finally we add the ADSR as an amplitude modulator
}
output[0]=mix*0.5;//left channel
output[1]=mix*0.5;//right channel
// This just sends note-off messages.
for (int i=0; i<6; i++) {
ADSR[i].trigger=0;
}
}
void play(double *output) {
if (counter ==0 || counter % 8820==0) {
myEnv.trigger(true);
}
counter++;
double out = myEnv.ar(0.01,1);
output[0]=myOsc.sinewave(440)*out;
output[1]=output[0];
}
void play(double *output) {
myClock.ticker(); // This makes the clock object count at the current samplerate
//This is a 'conditional'. It does a test and then does something if the test is true
if (myClock.tick) { // If there is an actual tick at this time, this will be true.
freq+=100; // DO SOMETHING
} // The curly braces close the conditional
//output[0] is the left output. output[1] is the right output
output[0]=mySine.sinewave(freq);//simple as that!
output[1]=output[0];
}
void play(double *output) {//this is where the magic happens. Very slow magic.
*output=mySine.sinewave(440);//simple as that!
}
void play(double *output) {
output[0]=mySine.sinewave(440);
output[1]=output[0];
}
void play(double *output) {
output[0]=mySine.sinewave(myOtherSine.sinewave(myLastSine.sinewave(0.1)*30)*440);//awesome bassline
output[1]=output[0];
}
void play(double *output) {
*output=mySine.sinewave(myOtherSine.sinewave(1)*440);
}
