path: root/gui/src/ofApp.cpp

#include "ofApp.h"
#include "glew.h"

const ofPoint mainwindowsize=ofPoint(1200,900);

//--------------------------------------------------------------
void ofApp::setup(){
	warpframe[0]=glm::vec2(0,0);
    warpframe[1]=glm::vec2(mainwindowsize.x,0);
    warpframe[2]=glm::vec2(mainwindowsize.x,mainwindowsize.y);
    warpframe[3]=glm::vec2(0,mainwindowsize.y);
    select_warpframe=-1;
    bDrawFrame=false;

    gui.setup();

    //==================================================== ofxNDI

	senderName[0] = 0;    // The sender name used for display
	nSenders = 0;         // Total number of NDI senders
	senderWidth = 0;      // Sender width
	senderHeight = 0;     // Sender height
	bNDIreceiver = false; // Receiver creation

	// Create an intial receiving image
	ndiImage.allocate(ofGetWidth(), ofGetHeight(), OF_IMAGE_COLOR_ALPHA);

	// For received frame fps calculations - independent of the rendering rate
	startTime = lastTime = frameTime = 0;
	fps = frameRate = 1; // starting value

	//============================ GUI

	gui.add(NDIthreshold.setup("threshold", 140, 0, 255));
	gui.add(NDIsimplify.setup("simplify", 0.2f, 0.0f, 1.0f));
	gui.add(NDIuseColour.setup("use colour", true));
	gui.add(NDIcolR.setup("red", 140, 0, 255));
	gui.add(NDIcolR.setup("green", 140, 0, 255));
	gui.add(NDIcolG.setup("blue", 140, 0, 255));


}

//--------------------------------------------------------------
void ofApp::updateOutput(ofEventArgs & args){


}

void ofApp::update(){

	// Update the NDI sender list to find new senders
	// There is no delay if no new senders are found
	nSenders = ndiReceiver.FindSenders();
	
	if(nSenders > 0) {

		// Has the user changed the sender index ?
		if(ndiReceiver.SenderSelected()) {
			// Release the current receiver.
			// A new one is then created from the selected sender index.
			ndiReceiver.ReleaseReceiver();
			bNDIreceiver = false;
		}

		// Create a new receiver if one does not exist.
		// We don't know the sender dimensions until a frame is received.
		if(!bNDIreceiver) {

			// The receiver will detect which format a sender is using and convert
			// the pixel buffer to BGRA for return. However, we can specify here
			// that RGBA is the preferred format.
			bNDIreceiver = ndiReceiver.CreateReceiver(NDIlib_recv_color_format_e_RGBX_RGBA);
			// bNDIreceiver = ndiReceiver.CreateReceiver(); // default is BRRA
			
			//
			// A receiver is created from an index into a list of sender names.
			// The current user selected index is saved in the NDIreceiver class
			// and is used to create the receiver unless you specify a particular index.
			//
			// The name of the sender can also be retrieved if you need it.
			// If you specified a particular sender index to create the receiver
			// use that index to retrieve it's name.
			//
			// In this application we use it to display the sender name.
			//

			ndiReceiver.GetSenderName(senderName);
			if(bNDIreceiver)
				cout << "Created NDI receiver for " << senderName << endl;

			// Reset the starting values for frame rate calulations
			fps = frameRate = 1;

		}

	}

	if(bNDIreceiver) {

		unsigned int width = 0;
		unsigned int height = 0;

		// If the NDI sender uses BGRA format, the received buffer is converted to rgba by ReceiveImage.
		// Optionally you can flip the image if necessary.
		
		// !CHECKME MACOS
		// ReceiveImage needs an unsigned char* so changed
		// ndiImage.getPixels() to ndiImage.getPixels().getData()
		// to avoid type error
		if(ndiReceiver.ReceiveImage(ndiImage.getPixels().getData(), width, height, false)) {  // receives as rgba

			ndiImage.update();

			// ----------------------------
			// Calculate received frame fps
			lastTime = startTime;
			startTime = ofGetElapsedTimeMicros();
			frameTime = (startTime - lastTime)/1000000; // seconds
			if( frameTime  > 0.01) {
				frameRate = floor(1.0/frameTime + 0.5);
				// damping from a starting fps value
				fps *= 0.95;
				fps += 0.05*frameRate;
			}
			// ----------------------------

			// Have the NDI sender dimensions changed ?
			if(senderWidth != width || senderHeight != height) {
				
				// Update the sender dimensions
				senderWidth  = width;
				senderHeight = height;
				
				// Update the receiving image size
				ndiImage.allocate(senderWidth, senderHeight, OF_IMAGE_COLOR_ALPHA);
				
			}
		}

	}
	
}

const ofPoint previewframesize=ofPoint(320,240);

//--------------------------------------------------------------	
void ofApp::draw(){
	ofBackground(0);

	ofSetColor(255);
	ofNoFill();

	gui.draw();

	//================================== NDI

	glPushMatrix();

	glTranslatef(256,0,0);

	ofDrawRectangle(20,20,previewframesize.x+4,previewframesize.y+4);

	char str[256];

	if(bNDIreceiver) {

		ndiImage.draw(22, 22, previewframesize.x, previewframesize.y);

		// Show fps etc.
		if(nSenders > 0) {
			if(bNDIreceiver) {
				#ifdef _MSC_VER
					sprintf_s(str, 256, "[%s] (%dx%d) - fps %2.0f", senderName, senderWidth, senderHeight, fps);
				#else
					// !CHECK MACOS
					snprintf(str, 256, "[%s] (%dx%d) - fps %2.0f", senderName, senderWidth, senderHeight, fps);
					str[255] = 0;
				#endif
				ofDrawBitmapString(str, 20, previewframesize.y+42);
			}

			if(nSenders == 1) {
				ofDrawBitmapString("1 network source", 25, 32);
			}
			else {
				#ifdef _MSC_VER
					sprintf_s(str, 256, "%d network sources", nSenders);
				#else
					// !CHECK MACOS
					snprintf(str, 256, "%d network sources", nSenders);
					str[255] = 0;
				#endif
				ofDrawBitmapString(str, 25, 32);
				//ofDrawBitmapString("'SPACE' to list senders or RH click to open sender dialog", 20, ofGetHeight()-20);
			}
		}
	}
	else {
		ofDrawBitmapString("Connecting . . .", 25, 32);
	}

	glPopMatrix();

}

void ofApp::drawOutput(ofEventArgs & args){
	ofBackground(0);
	//composite output window

	ofSetColor(255,255,255);

	ofMatrix4x4 m = ofMatrix4x4::newIdentityMatrix();
    m.rotateRad(ofGetElapsedTimef(),0,0,1);
    m.translate(ofGetWidth()/2,ofGetHeight()/2,0);

    glm::vec2 src[]={
    	glm::vec2(0,0),
    	glm::vec2(ofGetWidth(),0),
    	glm::vec2(ofGetWidth(),ofGetHeight()),
    	glm::vec2(0,ofGetHeight())
    };

    ofMatrix4x4 warp =lineTransformer::getPerspectiveTransformMatrix(src,warpframe);

    //drawPoly(polyLineTransform(makePolygon(4,200),m),200,200);
    //drawPoly(polyLineTransform(makePolygon(5,200),m),-200,200);
    //drawPoly(polyLineTransform(makePolygon(6,200),m),-200,-200);

    lineTransformer::drawPoly(
    	lineTransformer::polyLineTransform(
    		lineTransformer::polyLineTransform(
    			lineTransformer::makePolygon(6,200)
    			,m)
    		,warp)
    	,0,0);

    if (bDrawFrame){
    	lineTransformer::drawWarpFrame(warpframe);
    }

}

//--------------------------------------------------------------
void ofApp::exit() {

}



//--------------------------------------------------------------
void ofApp::outputKeyPressed(ofKeyEventArgs &args){

	if (args.key==OF_KEY_COMMAND){
		commandPressed=true;
	}

	switch(args.key){
		case 'w':{
			bDrawFrame=!bDrawFrame;
			break;
		}	
		case OF_KEY_COMMAND:{
			commandPressed=true;
		}
	}


}

void ofApp::keyPressed(ofKeyEventArgs &args){

}

//--------------------------------------------------------------
void ofApp::keyReleased(int key){
	if (key==OF_KEY_COMMAND){
		commandPressed=false;
	}
}


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

}

//--------------------------------------------------------------
void ofApp::outputMouseDragged(ofMouseEventArgs & args){
	if (select_warpframe>-1){
		warpframe[select_warpframe]=glm::vec2(args.x,args.y);
	}
}

void ofApp::mouseDragged(int x, int y, int button){
}

//--------------------------------------------------------------
void ofApp::outputMousePressed(ofMouseEventArgs & args){
	for (int i=0;i<4;i++){
		if (ofPoint(args.x,args.y).distance(warpframe[i])<25){
			select_warpframe=i;
		}
	}
}

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

//--------------------------------------------------------------
void ofApp::outputMouseReleased(ofMouseEventArgs & args){
	select_warpframe=-1;
}

void ofApp::mouseReleased(int x, int y, int button){
}

//--------------------------------------------------------------
void ofApp::mouseEntered(int x, int y){

}

//--------------------------------------------------------------
void ofApp::mouseExited(int x, int y){

}

//--------------------------------------------------------------
void ofApp::outputWindowResized(ofResizeEventArgs &resizeargs){

}

void ofApp::windowResized(int w, int h){

}


//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){ 
	//std::string filenames;
	
	//for (auto f = dragInfo.files.begin(); f != dragInfo.files.end(); f++){
	//	if (f!=dragInfo.files.begin()){
	//		filenames=filenames+", ";
	//	}
	//	filenames=filenames+*f;

	//	if (dragInfo.position.y<200){
	//		sets[0].addfiles(dragInfo.files); //,dragInfo.position);
	//	}
	//	else sets[1].addfiles(dragInfo.files); //,dragInfo.position);

		
	//}
	
}