path: root/src/testApp.cpp

#include "testApp.h"
previewWindow::~previewWindow(){
	cout << "preview window destroyed" << endl;
}
void previewWindow::setup(){}
void previewWindow::setParent(testApp *p){
	parent=p;
}
void previewWindow::draw(){

	for (auto i:parent->viewports) i.draw(parent->brightSlider,parent->previewscale);

}
void previewWindow::dragEvent(ofDragInfo dragInfo, ofxFenster* win){

    parent->dragEvent(dragInfo);
}
//--------------------------------------------------------------
guiWindow::~guiWindow(){
	cout << "gui window destroyed" << endl;
}
void guiWindow::setup(){}
void guiWindow::setParent(testApp *p){
	parent=p;
}
void guiWindow::draw(){

	parent->gui.draw();

}
void guiWindow::dragEvent(ofDragInfo dragInfo, ofxFenster* win){
    int sta=dragInfo.files[0].find_last_of("\\/")+1;
    int len=(dragInfo.files[0].find_last_of(".")+4)-sta;
	string filename=dragInfo.files[0].substr(sta,len);

	if (filename.length()) {
		palette p;
		if (p.load(filename)) {
			printf("loaded %s\n",filename.c_str());
			for (int i=0;i<parent->viewports.size();i++) {
				parent->viewports[i].Palette=p;
			}
		}
		else printf("could not load %s\n",filename.c_str());
	}
    parent->dragEvent(dragInfo);
}
//--------------------------------------------------------------
void testApp::create1port(bool & pressed){
	if (!pressed) return;
	viewports.clear();
	viewports.push_back(viewport(4*windowsize,2*windowsize,0,0,0));
	createports(1);
}
void testApp::create2port(bool & pressed){
	if (!pressed) return;
	viewports.clear();
	viewports.push_back(viewport(2*windowsize,2*windowsize,0,0,0));
	viewports.push_back(viewport(2*windowsize,2*windowsize,2*windowsize,0,1));
	createports(2);
}
void testApp::create4port(bool & pressed){
	if (!pressed) return;
	viewports.clear();
	viewports.push_back(viewport(windowsize,2*windowsize,0,0,0));
	viewports.push_back(viewport(windowsize,2*windowsize,windowsize,0,1));
	viewports.push_back(viewport(windowsize,2*windowsize,2*windowsize,0,2));
	viewports.push_back(viewport(windowsize,2*windowsize,3*windowsize,0,3));
	
	createports(4);
}
void testApp::create8port(bool & pressed){
	if (!pressed) return;
	viewports.clear();
	viewports.push_back(viewport(windowsize,windowsize,0,0,0));
	viewports.push_back(viewport(windowsize,windowsize,(1*windowsize),0,1));
	viewports.push_back(viewport(windowsize,windowsize,(2*windowsize),0,2));
	viewports.push_back(viewport(windowsize,windowsize,(3*windowsize),0,3));
	viewports.push_back(viewport(windowsize,windowsize,0,windowsize,4));
	viewports.push_back(viewport(windowsize,windowsize,(1*windowsize),windowsize,5));
	viewports.push_back(viewport(windowsize,windowsize,(2*windowsize),windowsize,6));
	viewports.push_back(viewport(windowsize,windowsize,(3*windowsize),windowsize,7));
	createports(8);
}
void testApp::createports(int num){
	cerr<<"created "<<num<<" ports"<<endl;
}
//--------------------------------------------------------------
void testApp::setup(){

	previewscale=5;

	showFPS=false;
	ofBackground(0,0,0);
	ofSetBackgroundAuto(true);
	ofSetFrameRate(60);

	//preview window stuff
	prevWin=new previewWindow();
	win=ofxFensterManager::get()->createFenster(0, 0,  windowsize*4*previewscale, windowsize*2*previewscale, OF_WINDOW);
	ofAddListener(win->events.keyPressed, this, &testApp::keyPressedEvent);
	win->setWindowTitle("preview");
	win->addListener(prevWin);
	prevWin->setup();
	prevWin->setParent(this);

	fullscreenoutput=false;

	guiWin=new guiWindow();
	gui.setup("","panel.xml",0,0);

	brightSlider=0;
	gui.add(bS.setup("brightness",brightSlider,0,255,255));

	fadeSlider=0;
	gui.add(fS.setup("fade",fadeSlider,0,255,255));

	gui.add(create_1.setup("1"));
	create_1.addListener(this,&testApp::create1port);
	gui.add(create_2.setup("2"));
	create_2.addListener(this,&testApp::create2port);
	gui.add(create_4.setup("4"));
	create_4.addListener(this,&testApp::create4port);
	gui.add(create_8.setup("8"));
	create_8.addListener(this,&testApp::create8port);

	gui.add(fill.setup("fill", false));
	slidFreq=1.0f;
	gui.add(sF.setup("freq",slidFreq,0,1.0,255));

	gui.add(wave.setup("wave", false));
	gui.add(fillwave.setup("wave fill", false));
	slidThickness=1.0f;
	gui.add(sT.setup("thickness",slidThickness,0,10.0,255));
	slidWave=1.0f;
	gui.add(sW.setup("amplitude",slidWave,0,4.0,255));

/*
	gui.setup("","panel.xml",0,0);
	gui.add(reversemain.setup("reverse main", false));
	gui.add(controlColours.setup("control colours", false));
	gui.add(noteRandomiseColours.setup("randomise note colours", false));
	gui.add(transparentBlack.setup("transparent black", false));
	gui.add(resetDrawscale.setup("reset draw scale"));
	gui.add(resetFBscale.setup("reset FB scale"));
	fadeScale=128;
	gui.add(fS.setup("fade scale",fadeScale,0,255,255));
	decayTime=1.0f;
	gui.add(dT.setup("decay time",decayTime,0,10.0,255));

	gui.add(oscScale.setup("scale size LFO", false));
	gui.add(breakOsc.setup("break oscillators", false));
	gui.add(randomOsc.setup("randomise oscillators", false));
	scaleAmplitude=0.5f;
	gui.add(sA.setup("fade scale",scaleAmplitude,0,2.0,255));
	scaleFrequency=1.0f;
	gui.add(sF.setup("fade freq",scaleFrequency,0,5.0,255));

	resetDrawscale.addListener(this,&testApp::resetDrawscalePressed);
	resetFBscale.addListener(this,&testApp::resetFBscalePressed);
	*/

	//gui window stuff
	ofxFenster* win2=ofxFensterManager::get()->createFenster(0, 0,  200, 400, OF_WINDOW);

	win2->setWindowTitle("config");
	win2->addListener(guiWin);
	guiWin->setup();
	guiWin->setParent(this);

	
	soundStream.listDevices();
	
	//if you want to set a different device id 
	//soundStream.setDeviceID(4); //bear in mind the device id corresponds to all audio devices, including  input-only and output-only devices.
	
	
	
	

	soundStream.setup(this, 0, 2, 44100, bufferSize, 4);
}


//--------------------------------------------------------------
void testApp::audioIn(float * input, int bufferSize, int nChannels){	
	
	float curVol = 0.0;
	
	// samples are "interleaved"
	int numCounted = 0;	

	//lets go through each sample and calculate the root mean square which is a rough way to calculate volume	
	for (int i = 0; i < bufferSize; i++){
		control.left[i]		= input[i*2]*0.5;
		control.right[i]	= input[i*2+1]*0.5;

		curVol += control.left[i] * control.left[i];
		curVol += control.right[i] * control.right[i];
		numCounted+=2;
	}
	
	//this is how we get the mean of rms :) 
	curVol /= (float)numCounted;
	
	// this is how we get the root of rms :) 
	curVol = sqrt( curVol );
	
	control.smoothedVol *= 0.93;
	control.smoothedVol += 0.07 * curVol;
	
	control.bufferCounter++;
	
}




//--------------------------------------------------------------
void testApp::update(){
	control.update();
	control.fill=fill;
	control.freq=slidFreq;
	control.wave=wave;
	control.thickness=slidThickness;
	control.fillwave=fillwave;
	control.waveheight=slidWave;
	control.fade=(uint8_t)fadeSlider;
}

//--------------------------------------------------------------
void testApp::draw(){


	for (auto i:viewports) i.drawport(control);

	ofPushMatrix();
		ofTranslate((ofGetWidth()/2)-(2*windowsize),(ofGetHeight()/2)-windowsize);
		for (auto i:viewports) i.draw((uint8_t)brightSlider);
	ofPopMatrix();

	ofSetColor(255,255,255);
	if (showFPS) ofDrawBitmapString(ofToString(ofGetFrameRate(), 2),20,20);

}

//--------------------------------------------------------------
void testApp::keyPressed(int key, ofxFenster* win){
	if(key == ' '){
			fullscreenoutput=!fullscreenoutput;
			win->setFullscreen(fullscreenoutput);
			printf("resolution: %ix%i %s\n",win->getWidth(),win->getHeight(),fullscreenoutput?"fullscreen":"windowed");
	}
	else keyPressed(key);
}
void testApp::keyPressed(int key){

		if(key == 'f'){
			toggleFPS();
		}
		if(key == OF_KEY_UP){
			control.yshift--;
		}
		if(key == OF_KEY_DOWN){
			control.yshift++;
		}
		if(key == OF_KEY_LEFT){
			control.xshift--;
		}
		if(key == OF_KEY_RIGHT){
			control.xshift++;
		}

}

//--------------------------------------------------------------
void testApp::keyReleased(int key){

}

//--------------------------------------------------------------
void testApp::mouseMoved(int x, int y ){

}

//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){

}

//--------------------------------------------------------------
void testApp::mouseReleased(int x, int y, int button){


}
void testApp::mousePressed(int x, int y, int button) {
}

//--------------------------------------------------------------
void testApp::windowResized(int w, int h){

}

//--------------------------------------------------------------
void testApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void testApp::dragEvent(ofDragInfo dragInfo, ofxFenster* win){
	

    dragEvent(dragInfo);
}
void testApp::dragEvent(ofDragInfo dragInfo){
   
}



void testApp::mousePressedEvent(ofMouseEventArgs &args) {
	//printf("mouse: %i,%i %i of %ix%i\n",args.x,args.y,args.button,win->getWidth(),win->getHeight());
	//0-2
	switch (args.button) {
		case 0:
			control.xshift=args.x-(win->getWidth()/2);
			control.yshift=args.y-(win->getHeight()/2);
			break;
		case 1:
			control.scale=pow(pow(args.x-(win->getWidth()/2),2)+pow(args.y-(win->getHeight()/2),2),0.5)/(win->getWidth()*.1);
			break;
		case 2:
			control.fscale=(pow(pow(args.x-(win->getWidth()/2),2)+pow(args.y-(win->getHeight()/2),2),0.5)/(win->getWidth()))+0.5;
			break;
	}
}

void testApp::keyPressedEvent(ofKeyEventArgs &args) {
	//printf("window key pressed: %i (%c)\n",args.key,args.key);
	keyPressed(args.key);
}

void testApp::toggleFPS(){
	showFPS=!showFPS;
}