From fbbc891991aaef716b7e56870faa25a11b169ef1 Mon Sep 17 00:00:00 2001
From: Tim Redfern <tim@eclectronics.org>
Date: Thu, 12 Dec 2013 22:05:38 +0000
Subject: working setup for documentation: glitch gisabled

---
 06_performance/src/oni.cpp | 300 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 300 insertions(+)
 create mode 100644 06_performance/src/oni.cpp

(limited to '06_performance/src/oni.cpp')

diff --git a/06_performance/src/oni.cpp b/06_performance/src/oni.cpp
new file mode 100644
index 0000000..eaa80c8
--- /dev/null
+++ b/06_performance/src/oni.cpp
@@ -0,0 +1,300 @@
+#include "oni.h"
+
+void syncOniPlayer::addPlayer(string name){
+	//ofxOpenNI *o=new ofxOpenNI;
+	//o->setupFromONI(name,true);
+	//o->setPaused(true);
+	//players.push_back(o);
+	players.push_back(NULL);
+	filenames.push_back(name);
+	soundplayer.setLoop(false);
+	//players[players.size()-1]->setSpeed(0.0f);
+	//players[players.size()-1]->setup(true);
+	//players[players.size()-1]->start();
+	//players[players.size()-1]->startPlayer(name);
+}
+void syncOniPlayer::play(){
+
+	if (filenames[0]!=""){
+		for (int i=0;i<players.size();i++) {
+			
+			players[i]=new ofxOpenNI();
+			//players[i]->setSafeThreading(true);
+			players[i]->setupFromONI(filenames[i],true);
+			//players[i]->setSafeThreading(true);
+			//players[i]->addDepthGenerator();
+			//players[i]->addImageGenerator();
+			//players[i]->setRegister(true);
+			players[i]->setLooped(false);
+			//players[i]->setBaseUserClass(user);
+			players[i]->start();
+			//players[players.size()-1]->setSpeed(1.0f);
+
+			cerr<<"playing "<<filenames[i]<<endl;
+		}
+		
+		//sleep(2);
+		drawable=true;
+		
+		playerActive=true;
+	}
+	if (audio!="") {
+		soundplayer.loadSound(audio);
+		soundplayer.play();
+	}
+	startTime=ofGetElapsedTimef();
+}
+void syncOniPlayer::update(){
+	for (int i=0;i<players.size();i++) {
+		if (playerActive) players[i]->update();
+	}
+}
+void syncOniPlayer::pause(){
+	for (int i=0;i<players.size();i++) {
+		//players[players.size()-1]->setSpeed(0.0f);
+		players[i]->setPaused(true);
+	}
+}
+bool syncOniPlayer::isPlaying(){
+	if (players.size()&&playerActive) return players[0]->isPlaying();
+	else return false;
+}
+int syncOniPlayer::getCurrentFrame(){
+	if (players.size()) return players[0]->getCurrentFrame();
+	else return -1;
+}
+float syncOniPlayer::getPosition(){
+	if (players.size()) return players[0]->getPosition();
+	else return -1.0f;
+}
+void syncOniPlayer::drawWindows(){
+	if (!drawable) return;
+	for (int i=0;i<players.size();i++) {
+		if (players[i]==NULL) break;
+		ofTranslate(0, i * 400);
+		players[i]->drawDepth(50, 0,520,390);
+		players[i]->drawImage(600, 0,520,390);
+
+
+	}
+}
+void syncOniPlayer::drawCloud(int step){
+		int count;
+		for (int n=0;n<players.size();n++) {
+
+
+            const XnDepthPixel* depthmap=players[n]->getDepthGenerator().GetDepthMap();
+            //uint16_t* depthpixels=depthmap.getPixels();
+            int range=1700;
+
+            int depthW=players[n]->getWidth();
+            int depthH=players[n]->getHeight();
+
+            for (int i=0;i<depthW;i+=step) {
+
+                glBegin(GL_LINES);
+
+                for (int j=0;j<depthH;j+=step) {
+
+
+                    ofPoint p= players[n]->projectiveToWorld(ofPoint(i,j,(float)(depthmap[j*depthW+i])));
+                    //ofPoint p= projectiveToWorld(ofPoint(i,j,(float)depthmap[j*dmw+i]));
+
+                    if (p.z == 0 || p.z>range) continue;    // gets rid of background
+
+
+                    glColor4ub((unsigned char)255, (unsigned char)255, (unsigned char)255, (unsigned char)255);
+                    glVertex3f(p.x, p.y, p.z);
+                    //if (i==320&&j==160) cerr<<"world point: "<<p.x<<","<<p.y<<","<<p.z<<endl;
+                }
+
+                glEnd();
+            }
+
+        }
+
+    return;
+}
+#define DRAWCIRCLES true
+void syncOniPlayer::drawPoints(float _birth,float life,float dx,float dy, float dz,float size){
+	if (!drawable) return;
+
+	if (DRAWCIRCLES) {
+		glEnable(GL_PROGRAM_POINT_SIZE);
+	    glEnable(GL_POINT_SMOOTH);
+	    glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
+	    glEnable( GL_BLEND );
+	}
+    
+    //glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+    //glPointSize( size);
+    //glBegin(GL_POINTS);
+	float interval=ofGetElapsedTimef()-lastTime;
+	if (playerActive){
+		//apply envelope
+		float attackSeconds=0.0f;
+		float playOutFraction=0.9f;
+		float birth;
+		float clipTime=ofGetElapsedTimef()-startTime;
+		
+		lastTime=ofGetElapsedTimef();
+		if (clipTime<attackSeconds) {
+			//ramp in
+			birth=_birth*(clipTime/attackSeconds);
+		}
+		else if (players[0]->getPosition()>playOutFraction) {
+			//cerr<<"playing out!"<<endl;
+			birth=_birth*(1.0f-((players[0]->getPosition()-playOutFraction)/(1.0f-playOutFraction)));
+			//if it reaches the end stop creating points but allow old points to play out
+			if (players[0]->getPosition()>0.99) playerActive=false;
+		}
+		else birth=_birth;
+
+		//cerr<<birth<<" "<<clipTime<<" "<<players[0]->getPosition()<<endl;
+    
+		const XnDepthPixel* depthmap=players[0]->getDepthGenerator().GetDepthMap();
+	    const ofPixels& pixels=players[0]->getImagePixels();
+	    int range=1700;
+		int dmw=players[0]->getWidth();
+		int dmh=players[0]->getHeight();
+		if (dmw&&dmh){
+	        int step=pixels.getWidth()/dmw;
+	        for (int o=0;o<birth;o++) {
+	            int i=ofRandom(dmw);
+	            int j=ofRandom(dmh);
+	            ofPoint p= players[0]->projectiveToWorld(ofPoint(i,j,(float)depthmap[j*dmw+i]));
+	            if (p.z <100 || p.z>range) continue;
+	            //points.push_back(fpoint(p.x, p.y, p.z,pixels[((j*step*dmw)+(i*step))*3],pixels[((j*step*dmw)+(i*step))*3]+1,pixels[((j*step*dmw)+(i*step))*3]+2));
+	            //fpoint f=fpoint(p.x, p.y, p.z,pixels[((j*step*dmw)+(i*step))*3],pixels[((j*step*dmw)+(i*step))*3]+1,pixels[((j*step*dmw)+(i*step))*3]+2);
+	            //f.draw(life,dx,dy,dz);
+	            if (pointPool.size()) {//take 1st dead particle
+	            	points[(*pointPool.begin())].setup(p.x, p.y, p.z,
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]],
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]+1],
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]+2]
+	            		);
+	            	pointPool.erase(pointPool.begin());
+	            }
+				else {//make a new one
+					points.push_back(fpoint());
+					points[points.size()-1].setup(p.x, p.y, p.z,
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]],
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]+1],
+	            		LUT[pixels[((j*step*dmw)+(i*step))*3]+2]);
+				}
+	        }
+		}
+	}
+	//cerr<<"drawing "<<points.size()<<" points, pointpool "<<pointPool.size()<<endl;
+	for (int i=0;i<points.size();i++){
+	    if (!points[i].draw(life,dx,dy,dz,size,interval)) {
+	    	pointPool.insert(i);
+	    }
+	}
+	if (DRAWCIRCLES) {
+	    glDisable( GL_BLEND );
+	    glDisable(GL_PROGRAM_POINT_SIZE);
+	}
+}
+int syncOniPlayer::getNumParticles(){
+	return points.size()-pointPool.size();
+}
+string syncOniPlayer::getCurrentFile(){
+	return filenames[0]+" "+audio;
+}
+void syncOniPlayer::stop(){
+	drawable=false;
+	playerActive=false;
+	soundplayer.stop();
+	for (int i=0;i<players.size();i++) {
+		if (players[i]!=NULL) {
+			//players[i]->stopCommon();
+			players[i]->stop();
+			//delete players[i]; how to do with thread safety? this doesn't even partly fix it
+			players[i]=NULL;
+		}
+	}
+	
+}
+//=================
+void oniManager::init(const char* filename){
+	playing=-1;
+    int numDevices=1;
+    string f=string(filename);
+    if( !XML.loadFile(f) ){
+        printf("unable to load recordings, check data/ folder\n");
+    }else{
+        if(XML.pushTag("TRSS")) {
+            int num=XML.getNumTags("rec");
+            if(num) {
+                for (int i=0;i<num;i++) {
+                    players.push_back(syncOniPlayer());
+                    players[i].addPlayer(XML.getAttribute("rec","left","",i));
+                    if (numDevices==2) {
+                        players[i].addPlayer(XML.getAttribute("rec","right","",i));
+                    }
+                    players[i].audio=XML.getAttribute("rec","audio","",i);
+                }
+            }
+            else printf("no recordings found!\n");
+        }
+    }
+}
+void oniManager::startPlayer(int newplayer){
+	if (players.size()>newplayer){
+	    if (playing>-1) {
+	    	players[playing].stop(); 
+	    }
+
+	    ///seg fault is definately caused by stopping
+	    ///==if you remove the stop condition, crash doesn't happen
+	    ///however cpu load becomes too much
+	    ///similarly keeping all movies in ram fucks up
+	    //does seg fault happen even if only stopping?
+	    ///how come on the mac we see crashing even in the middle of a sequence?
+
+	    //usleep(10000);
+	    	playing=newplayer;
+	    	players[playing].play();
+	    
+	}
+}
+string oniManager::getCurrentFile(){
+	if (players.size()>playing&&playing>-1) return players[playing].getCurrentFile();
+	else return "";
+}
+int oniManager::getNumClips(){
+	return players.size();
+}
+void oniManager::update(){
+	//if (playing>-1&&!players[playing].isPlaying()) players[playing].play();
+	if (players.size()>playing&&playing>-1) players[playing].update();
+}
+void oniManager::drawWindows(){
+	if (players.size()>playing&&playing>-1) players[playing].drawWindows();
+}
+void oniManager::drawCloud(int step){
+	if (players.size()>playing&&playing>-1) players[playing].drawCloud(step);
+}
+void oniManager::next(){
+	int newp=(playing+1)%players.size();
+	startPlayer(newp);
+}
+void oniManager::previous(){
+	int newp=playing-1<0?players.size()-1:playing-1;
+	startPlayer(newp);
+}
+int oniManager::getNumParticles(){
+	if (players.size()>playing&&playing>-1) return players[playing].getNumParticles();
+	else return 0;
+}
+void oniManager::drawPoints(float size,float birth,float life,float dx,float dy, float dz){
+	if (players.size()>playing&&playing>-1) {
+	    players[playing].drawPoints(birth,life,dx,dy,dz,size);
+	}
+}
+syncOniPlayer* oniManager::getCurrentPlayer(){
+	if (players.size()>playing&&playing>-1) return &players[playing];
+	else return NULL;
+}
+
-- 
cgit v1.2.3