summaryrefslogtreecommitdiff
path: root/06_performance/src/testApp.cpp
diff options
context:
space:
mode:
Diffstat (limited to '06_performance/src/testApp.cpp')
-rw-r--r--06_performance/src/testApp.cpp1119
1 files changed, 1119 insertions, 0 deletions
diff --git a/06_performance/src/testApp.cpp b/06_performance/src/testApp.cpp
new file mode 100644
index 0000000..12cec8f
--- /dev/null
+++ b/06_performance/src/testApp.cpp
@@ -0,0 +1,1119 @@
+#include "testApp.h"
+
+ /*
+ maybe draw pixel lines to a range of buffers and then play them in various 3D directions
+ pixel lines can have nice, missing corners and be nicely smoothed
+
+ is it insane not to do this in vvvv
+
+ can there be an editing interface
+
+ have a play with vvvv/ max and try to replicate this idea QUICKLY?
+ */
+
+
+//--------------------------------------------------------------
+void testApp::setup(){
+
+ midiIn.listPorts();
+
+ midiIn.openPort(0); //this was 1 on linux, 0 on OSX
+ //using 0 for midi through and jack audio connection kit to merge signals
+ midiIn.addListener(this);
+
+ midiOut.listPorts();
+ midiOut.openPort(1); //this was 1 on linux, 0 on OSX
+ //using 5 to send back to rehringer
+
+ // 0 output channeLs,
+ // 2 input channels
+ // 44100 samples per second
+ // BUFFER_SIZE samples per buffer
+ // 4 num buffers (latency)
+
+ soundStream.listDevices();
+
+ left = new float[BUFFER_SIZE];
+ right = new float[BUFFER_SIZE];
+
+ //soundStream.setDeviceID(7); //ignore to use default?
+ soundStream.setup(this, 0, 2, 44100, BUFFER_SIZE, 4);
+ //soundStream.setup(this, 0, 4, 44100, BUFFER_SIZE, 4);
+
+ ofSetHexColor(0x666666);
+
+ lFFTanalyzer.setup(44100, BUFFER_SIZE/2,32);
+
+ lFFTanalyzer.peakHoldTime = 15; // hold longer
+ lFFTanalyzer.peakDecayRate = 0.95f; // decay slower
+ lFFTanalyzer.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+ lFFTanalyzer.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+ rFFTanalyzer.setup(44100, BUFFER_SIZE/2,32);
+
+ rFFTanalyzer.peakHoldTime = 15; // hold longer
+ rFFTanalyzer.peakDecayRate = 0.95f; // decay slower
+ rFFTanalyzer.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+ rFFTanalyzer.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+/*
+=======
+
+ if (4chan)
+ {
+ lFFTanalyzer2.setup(44100, BUFFER_SIZE/2,32);
+
+ lFFTanalyzer2.peakHoldTime = 15; // hold longer
+ lFFTanalyzer2.peakDecayRate = 0.95f; // decay slower
+ lFFTanalyzer2.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+ lFFTanalyzer2.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+
+ rFFTanalyzer2.setup(44100, BUFFER_SIZE/2,32);
+
+ rFFTanalyzer2.peakHoldTime = 15; // hold longer
+ rFFTanalyzer2.peakDecayRate = 0.95f; // decay slower
+ rFFTanalyzer2.linearEQIntercept = 0.9f; // reduced gain at lowest frequency
+ rFFTanalyzer2.linearEQSlope = 0.01f; // increasing gain at higher frequencies
+ }
+<<<<<<< HEAD
+ */
+
+
+ ofSetFrameRate(60);
+
+ ofBackground(0,0,0);
+
+ F_movieSpeed=0.0;
+
+
+ //REMOVED 121113
+ //blendImage.loadImage("blend01.png");
+ //blendImage.loadMovie("blend.mp4");
+ //blendImage.play();
+ //blendImage.setLoopState(OF_LOOP_NORMAL);
+ //blendImage.setSpeed(F_movieSpeed);
+
+ I_movieSource=0;
+ I_moviePlaying=0;
+
+ //REMOVED 121113
+ renderImage.allocate(ofGetWidth(),ofGetHeight(),GL_RGB);
+ //renderImage.allocate(4080,768,GL_RGB);
+ //maskShader.load("composite");
+
+ //testImage.loadImage("mask.png");
+
+ //REMOVED 121113
+ //maskShader.begin();
+ //maskShader.setUniformTexture("Tex0", blendImage.getTextureReference(), 0);
+ //maskShader.setUniformTexture("Tex1", renderImage.getTextureReference(), 1);
+ //maskShader.end();
+
+ showFPS=false;
+
+ //defaults
+
+ F_scale=0;
+ F_drawFrames=10;
+ F_drawStep=0;
+ F_drawDecay=0.95;
+
+ F_lineWidth=1.0; //1.0;
+
+ F_drawAxis=90; //Y
+
+
+ F_xRotate=0;
+ F_yRotate=0;
+ F_zRotate=0;
+
+ F_xRotation=180;
+ F_yRotation=0; //was 180
+ F_zRotation=0;
+
+ F_particleAmount=2000; //100
+ F_particleLife=1.5; //0.5
+ F_particleSize=10.0; //1.0;
+
+
+ I_fade1=0;
+ I_fade2=0;
+
+ thisFFTbuffer=0;
+
+ lastFrameTime=ofGetElapsedTimef();
+
+ draworder=true; //forwards;
+
+ visMode=WAVEFORM;
+
+ B_vSync=true;
+ B_fill=true;
+
+ inputMode=PICTURE;
+
+
+ gammamap=new unsigned char[256];
+
+
+ whitePt=0.9;
+ blackPt=0.3;
+ gamma=1.0;
+
+ //calc gamma map
+ for (int i=0;i<256;i++){
+ float ewp=max(whitePt,blackPt+0.1f); //limit range to 0.1
+ gammamap[i]=(unsigned char)(pow(min(1.0f,max(0.0f,(((float(i)/255.0f)-blackPt)/(ewp-blackPt)))),gamma)*255.0);
+ }
+
+ B_glitch=false;
+
+ //blanker.allocate(64,64,OF_IMAGE_COLOR);
+ blanker.loadImage("black.png");
+
+
+ fullScreen=false;
+
+ setMidiState();
+
+ receiver.setup(OSCPORT);
+
+ target.setPosition(0,0,0);
+ camera.setPosition(0,0,-700);
+ camera.lookAt(target,ofVec3f(0,1,0));
+ narrator.init("TRSS_nesbitt_recordings.xml");
+
+ if( !XML.loadFile("videos.xml") ){
+ printf("unable to load videos, check data/ folder\n");
+ }else{
+ if(XML.pushTag("TRSS")) {
+ int num=XML.getNumTags("video");
+ if(num) {
+ int i;
+ for (i=0;i<num;i++) {
+ videoclips.push_back(ofVideoPlayer());
+ videoclips[i].loadMovie(XML.getAttribute("video","file","",i));
+ videoclips[i].setLoopState(OF_LOOP_NONE);
+ videoclips[i].stop();
+ videoclips[i].setPosition(0.0f);
+ //videoclips[i].play();
+ //videoclips[i].setSpeed(0.0f);
+ }
+ cerr<<"loaded "<<i<<" video clips"<<endl;
+ }
+ else printf("no video clips found!\n");
+ }
+ }
+
+ int videoplaying=-1;
+
+ xOffs=startX=yOffs=startY=0;
+ xModel=0;
+ yModel=-25;
+ zModel=-825; //-1050;
+ sModel=3.5f;
+
+ newNarrator=-1;
+
+};
+
+
+
+
+//--------------------------------------------------------------
+void testApp::update(){
+
+ if (newNarrator>-1){
+ narrator.startPlayer(newNarrator);
+ newNarrator=-1;
+ }
+
+ // check for waiting messages
+ while(receiver.hasWaitingMessages()){
+ // get the next message
+ ofxOscMessage m;
+ receiver.getNextMessage(&m);
+
+
+ ///mrmr/pushbutton/6/Pauls-iPad 1000
+
+
+ vector<string> path;
+ explode(m.getAddress(),'/', back_inserter(path));
+
+ cerr<<"OSC: "<<m.getAddress()<<endl;
+
+ if (path.size()>1) {
+ if (path[1]=="mrmr"){
+ if (path.size()>3){
+ if (path[2]=="pushbutton"){
+ int channel=ofToInt(path[3]);
+ if (channel>12) channel--; //12 is missing
+ if (m.getArgAsInt32(0)==1000) {
+ if (videoplaying>-1&&videoclips.size()>channel) {
+ videoclips[videoplaying].stop();
+ videoclips[videoplaying].setPosition(0.0f);
+ }
+ //videoclips[channel].setPosition(0.0f);
+ //videoclips[channel].setSpeed(1.0f);
+ videoplaying=channel;
+ videoclips[channel].play();
+ }
+ }
+ }
+ }
+ else {
+ string type=path[1];
+ if (type=="narrator"||type=="video") {
+ int channel=ofToInt(path[2])-1;
+ int data=m.getArgAsInt32(0);
+
+ cerr<<"type: "<<type<<" channel: "<<channel<<" data: "<<data<<endl;
+
+ if (type=="video"){
+ if ((channel > -1)&&videoclips.size()>channel) {
+ if (data>0) {
+ cerr<<"playing video "<<channel<<endl;
+ if (videoplaying>-1&&videoclips.size()>channel) {
+ videoclips[videoplaying].stop();
+ videoclips[videoplaying].setPosition(0.0f);
+ }
+ //videoclips[channel].setPosition(0.0f);
+ //videoclips[channel].setSpeed(1.0f);
+ videoplaying=channel;
+ videoclips[channel].play();
+ }
+ }
+ }
+ if (type=="narrator"){
+ if ((channel > -1)&&narrator.getNumClips()>channel) {
+ if (data>0) { //???doesn't seem to work
+ cerr<<"playing narrator "<<channel<<endl;
+ narrator.startPlayer(channel);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+
+//REMOVED 121113
+/*
+ if (I_movieSource!=I_moviePlaying) {
+ blendImage.stop();
+ switch(I_movieSource){
+ case 0:
+ blendImage.loadMovie("gradblend.mov");
+ break;
+ case 1:
+ blendImage.loadMovie("gradblend01.mov");
+ break;
+ case 2:
+ blendImage.loadMovie("ll_waltz1.mov");
+ break;
+ case 3:
+ blendImage.loadMovie("ll_longtrains.avi");
+ break;
+
+ }
+ blendImage.play();
+ blendImage.setLoopState(OF_LOOP_NORMAL);
+ I_moviePlaying=I_movieSource;
+ }
+ blendImage.setSpeed(F_movieSpeed);
+ //blendImage.idleMovie();
+ */
+
+ if (videoplaying>-1&&videoclips.size()>videoplaying) videoclips[videoplaying].update();
+ //if (videoclips[i].getSpeed()>0.01f) videoclips[i].update();
+ //if (videoclips[i].getPosition()>0.99f) videoclips[i].setSpeed(0.0f);
+ //if (videoclips[i].isPlaying()) videoclips[i].stop();
+ //}
+
+ narrator.update();
+
+ xOffs*=.95;
+ yOffs*=.95;
+
+}
+
+//--------------------------------------------------------------
+void testApp::draw(){
+ ofSetVerticalSync(B_vSync);
+
+
+
+ static int index=0;
+ float lavg_power = 0.0f;
+ float ravg_power = 0.0f;
+
+ if (visMode==FFT_RAW||visMode==FFT_AVG) {
+ myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, left,BUFFER_SIZE,&lmagnitude[0],&lphase[0],&lpower[0],&lavg_power);
+ myfft.powerSpectrum(0,(int)BUFFER_SIZE/2, right,BUFFER_SIZE,&rmagnitude[0],&rphase[0],&rpower[0],&ravg_power);
+ }
+ if (visMode==FFT_AVG) {
+ lFFTanalyzer.calculate(lmagnitude);
+ rFFTanalyzer.calculate(rmagnitude);
+ }
+
+ thisFFTbuffer=(thisFFTbuffer-1);
+ thisFFTbuffer=thisFFTbuffer<0?BUFFER_FRAMES-1:thisFFTbuffer;
+
+ switch(visMode) {
+ case FFT_AVG:
+ for (int i=0;i<rFFTanalyzer.nAverages;i++) {
+ FFTbuffer[0][i][thisFFTbuffer]=lFFTanalyzer.averages[i];
+ FFTbuffer[1][i][thisFFTbuffer]=rFFTanalyzer.averages[i];
+ }
+ break;
+ case FFT_RAW:
+ for (int i=0;i<BUFFER_SIZE;i++) {
+ FFTbuffer[0][i][thisFFTbuffer]=lmagnitude[i]*3;
+ FFTbuffer[1][i][thisFFTbuffer]=rmagnitude[i]*3;
+ }
+ break;
+ case WAVEFORM:
+ for (int i=0;i<BUFFER_SIZE/2;i++) {
+ FFTbuffer[0][i][thisFFTbuffer]=left[i]*100;
+ FFTbuffer[1][i][thisFFTbuffer]=right[i]*100;
+ }
+ break;
+ }
+
+ //ofDisableAlphaBlending();
+
+ //renderImage.begin(); //render to FOB
+ glDisable(GL_BLEND);
+
+ float hw=ofGetWidth()/2;
+ float hh=ofGetHeight()/2;
+ float xStep = ((float)ofGetWidth())/(lFFTanalyzer.nAverages*2);
+ float zStep = ((float)ofGetWidth())/F_drawFrames;
+
+ float newTime=ofGetElapsedTimef();
+ float interval=newTime-lastFrameTime;
+ lastFrameTime=newTime;
+
+
+ if (B_glitch) {
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+ //glBlendColor(1.0f,1.0f,1.0f,((float)I_fade2)/255.0f);
+ ofSetColor(255,255,255,I_fade2);
+ blanker.draw(0,0,renderImage.getWidth(),renderImage.getHeight());
+ glDisable(GL_BLEND);
+
+ }
+ else {
+ glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
+ }
+
+
+
+
+ F_xRotation+=(F_xRotate*interval);
+ F_yRotation+=((F_yRotate+xOffs)*interval);
+ F_zRotation+=((F_zRotate+yOffs)*interval);
+ F_drawFrames=max(1.99f,min(F_drawFrames+(F_drawStep*interval),(float)BUFFER_FRAMES));
+
+ ofPushMatrix();
+ //ofTranslate(hw,hh);
+ camera.begin();
+ camera.setFov(120);
+ ofRotateX(F_xRotation);
+ ofRotateY(F_yRotation);
+ ofRotateZ(F_zRotation);
+
+ /*
+ if (inputMode==GRABBER) {
+ ofSetColor(I_fade2,I_fade2,I_fade2);
+ ofPushMatrix();
+ ofRotateX(90);
+ ofRotateZ(-90);
+ outTexture.draw(hw,-hh,-ofGetWidth(),ofGetHeight());
+ ofPopMatrix();
+ }
+ */
+ GLfloat fogColor[4] = {0,0,0, 1.0};
+ glFogi(GL_FOG_MODE, GL_LINEAR);
+ glFogfv(GL_FOG_COLOR, fogColor);
+ glFogf(GL_FOG_DENSITY,1.0 );
+ glHint(GL_FOG_HINT, GL_DONT_CARE);
+ glFogf(GL_FOG_START, ofGetWidth()*(0.1+(F_drawDecay*5)));
+ glFogf(GL_FOG_END, ofGetWidth()*(0.5+(F_drawDecay*5))); //was *5 ofGetWidth()
+ glEnable(GL_FOG);
+
+ //reverse draw order when looking from back
+ int jStart=0;
+ int jEnd=F_drawFrames-1;
+ int jStep=1;
+ float F_yseg=F_yRotation;
+ while (F_yseg<-90) F_yseg+=360;
+ while (F_yseg>270) F_yseg-=360;
+ if (F_yseg>90) {
+ jStart=jEnd;
+ jEnd=0;
+ jStep=-1;
+ if (draworder) {
+ draworder=false;
+ //printf("switched to reverse order\n");
+ }
+ }
+ else if (!draworder) {
+ draworder=true;
+ //printf("switched to normal order\n");
+ }
+
+ for (int j=jStart;j!=jEnd;j+=jStep) {
+ int fB=(thisFFTbuffer+j)%BUFFER_FRAMES;
+
+ ofPushMatrix(); //coordinate transform for FFT draw direction
+ ofTranslate(0,0,(j*zStep)-hw);
+ ofRotateX(F_drawAxis);
+
+ ofFill();
+ ofSetColor(0,0,0);
+ if (B_fill) {
+ glBegin(GL_QUAD_STRIP);
+ for (int i = 0; i < lFFTanalyzer.nAverages-1; i++){
+ glVertex3f((i*xStep)-hw,(FFTbuffer[0][i][fB] * F_scale),0);
+ glVertex3f((i*xStep)-hw,0,0);
+ }
+ glEnd();
+ glBegin(GL_QUAD_STRIP);
+ for (int i =lFFTanalyzer.nAverages, k=lFFTanalyzer.nAverages-1; i < lFFTanalyzer.nAverages+rFFTanalyzer.nAverages; i++, k--){
+ glVertex3f((i*xStep)-hw,(FFTbuffer[1][(lFFTanalyzer.nAverages+rFFTanalyzer.nAverages)-(i+1)][fB] * F_scale),0);
+ glVertex3f((i*xStep)-hw,0,0);
+ }
+ glEnd();
+ }
+
+ ofNoFill();
+ ofSetLineWidth(F_lineWidth);
+ ofSetColor(I_fade1,I_fade1,I_fade1);
+ glBegin(GL_LINE_STRIP);
+ for (int i = 0; i < lFFTanalyzer.nAverages; i++){
+ glVertex3f((i*xStep)-hw,(FFTbuffer[0][i][fB] * F_scale),0);
+ }
+ for (int i =lFFTanalyzer.nAverages, k=lFFTanalyzer.nAverages-1; i < lFFTanalyzer.nAverages+rFFTanalyzer.nAverages; i++, k--){
+ glVertex3f((i*xStep)-hw,(FFTbuffer[1][(lFFTanalyzer.nAverages+rFFTanalyzer.nAverages)-(i+1)][fB] * F_scale),0);
+ }
+ glEnd();
+ ofPopMatrix();
+ }
+ camera.end();
+
+ ofPopMatrix();
+
+ if (videoplaying>-1&&videoclips.size()>videoplaying) {
+ if (videoclips[videoplaying].getPosition()<0.1f) {
+ glEnable(GL_BLEND);
+ uint8_t b=uint8_t((videoclips[videoplaying].getPosition()/0.1f)*255);
+ ofSetColor(255,255,255,b);
+ }
+ else if (videoclips[videoplaying].getPosition()>0.8f) {
+ glEnable(GL_BLEND);
+ uint8_t b=uint8_t((1.0f-((videoclips[videoplaying].getPosition()-0.8f)/0.2f))*255);
+ ofSetColor(255,255,255,b);
+ }
+ else ofSetColor(255,255,255);
+ videoclips[videoplaying].draw(0,0,renderImage.getWidth()/3,renderImage.getHeight());
+ videoclips[videoplaying].draw(renderImage.getWidth()*0.666666667,0,renderImage.getWidth()/3,renderImage.getHeight());
+ glDisable(GL_BLEND);
+ }
+ ofPushMatrix();
+ //ofTranslate(hw,hh);
+ camera.begin();
+ ofRotateX(F_xRotation);
+ ofRotateY(F_yRotation);
+ ofRotateZ(F_zRotation);
+
+ ofPushMatrix();
+ //ofTranslate(0,-100,-1050);
+ ofScale(sModel,sModel,sModel);
+ //ofTranslate(xModel*sModel,yModel*sModel,zModel*sModel);
+ ofTranslate(xModel,yModel,zModel);
+
+ //narrator.drawCloud(2);
+ narrator.drawPoints(F_particleSize,F_particleAmount,F_particleLife,F_particleX,F_particleY,F_particleZ);
+ ofPopMatrix();
+
+ ofSetColor(255,255,255);
+
+
+ camera.end();
+
+ ofPopMatrix();
+ //renderImage.end();
+
+
+
+
+ //ofEndShape(false);
+
+
+ //fbImage.grabScreen(0,0,ofGetWidth(),ofGetHeight());
+/*
+
+
+//REMOVED 121113
+
+ ofSetHexColor(0xaaaaaa);
+ int width=2048/FFTanalyzer.nAverages;
+ for (int i = 0; i < FFTanalyzer.nAverages; i++){
+ ofRect(i*width,768,width,-FFTanalyzer.averages[i] * 20);
+ }
+ ofSetHexColor(0xffffff);
+ for (int i = 0; i < (int)(BUFFER_SIZE/2 - 1); i++){
+ ofRect(i,768-freq[i]*10.0f,1,1);
+ }
+
+ ofSetHexColor(0xff0000);
+ for (int i = 0; i < FFTanalyzer.nAverages; i++){
+ ofRect(i*width,768-FFTanalyzer.peaks[i] * 20,width,-1);
+ }
+
+ float avgStep = 1024/FFTanalyzer.nAverages;
+
+
+ ofNoFill();
+ ofSetLineWidth(1);
+
+ ofSetColor(223, 218, 218);
+ ofDrawBitmapString("FFT average", 4, 18);
+ ofBeginShape();
+ for (int i = 0; i < FFTanalyzer.nAverages; i++){
+ ofVertex(i*avgStep, 284 -FFTanalyzer.averages[i] * 20);
+ }
+ ofEndShape(false);
+
+
+ ofSetColor(97,181,243);
+ ofDrawBitmapString("FFT magnitude", 4, 38);
+ ofBeginShape();
+ for (int i = 0; i < BUFFER_SIZE; i++){
+ ofVertex(i*avgStep, 384 -magnitude[i] * 20);
+ }
+ ofEndShape(false);
+
+
+ ofSetColor(97,243,174);
+ ofDrawBitmapString("FFT phase", 4, 58);
+ ofBeginShape();
+ for (int i = 0; i < BUFFER_SIZE; i++){
+ ofVertex(i*avgStep, 484 -phase[i] * 20);
+ }
+ ofEndShape(false);
+
+ ofSetColor(243,174,94);
+ ofDrawBitmapString("FFT power", 4, 78);
+ ofBeginShape();
+ for (int i = 0; i < BUFFER_SIZE; i++){
+ ofVertex(i*avgStep, 584 -power[i] * 20);
+ }
+ ofEndShape(false);
+
+
+ //float * averages; // the actual averages
+ //float * peaks; // peaks of the averages, aka "maxAverages" in other implementations
+
+*/
+
+
+ /*
+ ofEnableAlphaBlending();
+
+ maskShader.begin();
+
+ glActiveTexture(GL_TEXTURE0_ARB);
+ blendImage.getTextureReference().bind();
+ glActiveTexture(GL_TEXTURE1_ARB);
+ renderImage.getTextureReference().bind();
+
+ glBegin(GL_QUADS);
+
+ glMultiTexCoord2d(GL_TEXTURE0_ARB, 0, 0);
+ glMultiTexCoord2d(GL_TEXTURE1_ARB, 0, 0);
+ glVertex2f( 0, 0);
+
+ glMultiTexCoord2d(GL_TEXTURE0_ARB, blendImage.getWidth(), 0);
+ glMultiTexCoord2d(GL_TEXTURE1_ARB, renderImage.getWidth(), 0);
+ glVertex2f( ofGetWidth(), 0);
+
+ glMultiTexCoord2d(GL_TEXTURE0_ARB, blendImage.getWidth(), blendImage.getHeight());
+ glMultiTexCoord2d(GL_TEXTURE1_ARB, renderImage.getWidth(), renderImage.getHeight() );
+ glVertex2f( ofGetWidth(), ofGetHeight());
+
+ glMultiTexCoord2d(GL_TEXTURE0_ARB, 0, blendImage.getHeight());
+ glMultiTexCoord2d(GL_TEXTURE1_ARB, 0, renderImage.getHeight() );
+ glVertex2f( 0, ofGetHeight() );
+
+ glEnd();
+
+ glActiveTexture(GL_TEXTURE1_ARB);
+ renderImage.getTextureReference().unbind();
+
+ glActiveTexture(GL_TEXTURE0_ARB);
+ blendImage.getTextureReference().unbind();
+
+ maskShader.end();
+ */
+
+/*
+ glPushMatrix();
+ glTranslatef(ofGetWidth()*0.5,ofGetHeight()*0.5,0);
+ glRotatef((float)ofGetFrameNum(),0,1.0,0);
+ renderImage.draw(ofGetWidth()*-0.5,ofGetHeight()*-0.5);
+ glPopMatrix();
+ */
+
+
+
+ if (showFPS) {
+ string msg=ofToString(ofGetFrameRate(), 2);
+ msg+="\n"+ofToString(F_xRotation, 4)+" "+ofToString(F_yRotation, 4)+" "+ofToString(F_zRotation, 4);
+ msg+="\n"+ofToString(F_yseg, 4);
+ msg+="\n"+ofToString(narrator.getNumParticles())+" size "+ofToString(F_lineWidth);
+ msg+="\n"+ofToString(xModel)+","+ofToString(yModel)+","+ofToString(zModel)+" * "+ofToString(sModel);
+ syncOniPlayer *player=narrator.getCurrentPlayer();
+ if (player) {
+ msg+="\n"+ofToString(player->getCurrentFrame())+","+ofToString(player->getPosition(),2);
+ msg+="\n"+player->getCurrentFile();
+ }
+ ofDrawBitmapString(msg,20,20);
+ }
+}
+
+
+//--------------------------------------------------------------
+void testApp::keyPressed (int key){
+ if(key == 'f'){
+ showFPS=!showFPS;
+ }
+ if(key == ' '){
+ fullScreen=!fullScreen;
+ ofSetFullscreen(fullScreen);
+ }
+ if(key == '/'){
+ narrator.startPlayer(23);
+ }
+ if(key == ','){
+ narrator.previous();
+ }
+ if(key == '.'){
+ narrator.next();
+ }
+ if(key>='1'&key<='9'){
+ int clip=(key-'1'); //+13;
+ /*
+ cerr<<"playing video clip "<<clip<<endl;
+ if (videoclips.size()>clip) {
+ videoclips[videoplaying].stop();
+ videoclips[videoplaying].setPosition(0.0f);
+ videoclips[clip].play();
+ videoplaying=clip;
+ }
+ */
+ cerr<<"playing narrator "<<clip<<endl;
+ narrator.startPlayer(clip);
+ }
+
+ //Starting ONI player:../../../recs/kinectRecord_0_15201313304.oni
+ //-->ok
+
+ //Starting ONI player:../../../recs/kinectRecord_0_15201313204.oni
+ //-->crash
+
+
+ if(key == 't'){
+ for (int i=0;i<videoclips.size();i++) {
+ if (videoclips[i].isPlaying()) {
+ cerr<<"videoclip "<<i<<" is playing"<<endl;
+ }
+ }
+ }
+ if(key == 'r'){
+ yModel+=25;
+ }
+ if(key == 'v'){
+ yModel-=25;
+ }
+ if(key == 'd'){
+ xModel+=25;
+ }
+ if(key == 'g'){
+ xModel-=25;
+ }
+ if(key == 't'){
+ zModel+=25;
+ }
+ if(key == 'c'){
+ zModel-=25;
+ }
+ if(key == 'w'){
+ sModel*=1.02;
+ }
+ if(key == 's'){
+ sModel/=1.02;
+ }
+ if(key == 'q'){
+ I_fade1=min(I_fade1+1,255);
+ }
+ if(key == 'a'){
+ I_fade1=max(I_fade1-1,0);
+ }
+ if(key == 'h'){
+ F_particleX-=1;
+ }
+ if(key == 'k'){
+
+ F_particleX+=1;
+ }
+ if(key == 'm'){
+ F_particleY-=1;
+ }
+ if(key == 'u'){
+
+ F_particleY+=1;
+ }
+ if(key == 'i'){
+ F_particleZ+=1;
+ }
+ if(key == 'n'){
+
+ F_particleZ-=1;
+ }
+
+}
+
+//--------------------------------------------------------------
+void testApp::mouseMoved(int x, int y ){
+
+}
+
+//--------------------------------------------------------------
+void testApp::mouseDragged(int x, int y, int button){
+ xOffs=x-startX;
+ yOffs=y-startY;
+}
+
+//--------------------------------------------------------------
+void testApp::mousePressed(int x, int y, int button){
+ startX=x;
+ startY=y;
+}
+
+//--------------------------------------------------------------
+void testApp::mouseReleased(){
+}
+
+
+//--------------------------------------------------------------
+void testApp::audioIn(float * input, int bufferSize, int nChannels){
+ /*if (sampnum<10) {
+ printf("size %i, channels %i\n",bufferSize,nChannels);
+ sampnum++;
+ }
+ */
+ // samples are "interleaved"
+ //if (nChannels==2) {
+ for (int i = 0; i < bufferSize; i++){
+ left[i] = input[i*2];
+ right[i] = input[i*2+1];
+ }
+ //}
+
+}
+
+void testApp::newMidiMessage(ofxMidiMessage& eventArgs){
+
+ //newMessage(eventArgs.port, eventArgs.channel, eventArgs.bytes[1], eventArgs.timestamp);
+
+//byteOne : message type
+
+ /*
+ int port;
+ int channel;
+ int status;
+ int byteOne;
+ int bytes[1];
+ double timestamp;
+ */
+
+ //printf("%d %d %d %d\n",eventArgs.channel,eventArgs.status,eventArgs.bytes[1],eventArgs.bytes[2]);
+
+ bool noteOn; //this old thing!
+ int clip;
+
+ switch(eventArgs.status) {
+ case 192: //?what is this?
+ //printf("%d %d %d %d %d\n",eventArgs.port,eventArgs.channel,eventArgs.status,eventArgs.byteOne,eventArgs.bytes[1]);
+ //clip=eventArgs.bytes[1]+12;
+ //if (clip>12)
+ //cerr<<"playing narrator "<<clip<<endl;
+ //narrator.startPlayer(clip);
+ break;
+ case 144: //noteon-off
+ clip=eventArgs.bytes[1]-54;
+ if (clip>-1&&clip<narrator.getNumClips()){
+ cerr<<"playing narrator "<<clip<<endl;
+ newNarrator=clip;
+ //narrator.startPlayer(clip); crashes:thread issue?
+ }
+ break;
+ case 176: //control change 1-8 x 4 banks
+ switch(eventArgs.bytes[1]) {
+ case 1:
+ F_scale = ((float)eventArgs.bytes[2])*.25;
+ break;
+ case 2:
+ F_particleSize=(float)eventArgs.bytes[2]*0.25;
+ break;
+ case 3:
+ F_drawAxis=((float) eventArgs.bytes[2]-64)*(360.0/127);
+ break;
+ case 4:
+ F_particleAmount=((float) eventArgs.bytes[2])*(10000.0f/127.0f);
+ break;
+ case 5:
+ F_particleLife=((float) eventArgs.bytes[2])*(5.0f/127.0f);
+ break;
+ case 6:
+ F_particleX=(((float) eventArgs.bytes[2])-64)*2.0f;
+ break;
+ case 7:
+ F_particleY=(((float) eventArgs.bytes[2])-64)*2.0f;
+ break;
+ case 8:
+ F_particleZ=(((float) eventArgs.bytes[2])-64)*2.0f;
+ break;
+
+ //65-80 buttons
+
+ //radio button set
+ case 65:
+ if (eventArgs.bytes[2]==127) {
+ visMode=FFT_AVG;
+ midiOut.sendControlChange(1, 66, 0);
+ midiOut.sendControlChange(1, 67, 0);
+ }
+ else midiOut.sendControlChange(1, 65, 127);
+ break;
+ case 66:
+ if (eventArgs.bytes[2]==127) {
+ visMode=FFT_RAW;
+ midiOut.sendControlChange(1, 65, 0);
+ midiOut.sendControlChange(1, 67, 0);
+ }
+ else midiOut.sendControlChange(1, 66, 127);
+ break;
+ case 67:
+ if (eventArgs.bytes[2]==127) {
+ visMode=WAVEFORM;
+ midiOut.sendControlChange(1, 65, 0);
+ midiOut.sendControlChange(1, 66, 0);
+ }
+ else midiOut.sendControlChange(1, 67, 127);
+ break;
+
+ //radio button set
+ case 68:
+ if (eventArgs.bytes[2]==127) {
+ inputMode=PICTURE;
+ midiOut.sendControlChange(1, 69, 0);
+
+ }
+ else midiOut.sendControlChange(1, 68, 127);
+ break;
+ case 69:
+ if (eventArgs.bytes[2]==127) {
+ inputMode=GRABBER;
+ midiOut.sendControlChange(1, 68, 0);
+
+ }
+ else midiOut.sendControlChange(1, 69, 127);
+ break;
+ case 70:
+ B_glitch=(eventArgs.bytes[2]==127);
+ break;
+ case 71:
+ B_fill=(eventArgs.bytes[2]==127);
+ break;
+ case 72:
+ B_vSync=(eventArgs.bytes[2]==127);
+ break;
+
+ //buttons to zero rotations
+ case 73:
+ F_xRotate=0;
+ midiOut.sendControlChange(1, 73, 0);
+ midiOut.sendControlChange(1, 81, 64);
+ break;
+ case 74:
+ F_yRotate=0;
+ midiOut.sendControlChange(1, 74, 0);
+ midiOut.sendControlChange(1, 82, 64);
+ break;
+ case 75:
+ F_zRotate=0;
+ midiOut.sendControlChange(1, 75, 0);
+ midiOut.sendControlChange(1, 83, 64);
+ break;
+ case 76:
+ F_drawStep=0;
+ midiOut.sendControlChange(1, 76, 0);
+ midiOut.sendControlChange(1, 84, 64);
+ break;
+ case 77:
+ if (eventArgs.bytes[2]==127) {
+ I_movieSource=0;
+ midiOut.sendControlChange(1, 78, 0);
+ midiOut.sendControlChange(1, 79, 0);
+ midiOut.sendControlChange(1, 80, 0);
+
+ }
+ else midiOut.sendControlChange(1, 77, 127);
+ break;
+ case 78:
+ if (eventArgs.bytes[2]==127) {
+ I_movieSource=1;
+ midiOut.sendControlChange(1, 77, 0);
+ midiOut.sendControlChange(1, 79, 0);
+ midiOut.sendControlChange(1, 80, 0);
+ }
+ else midiOut.sendControlChange(1, 78, 127);
+ break;
+ case 79:
+ if (eventArgs.bytes[2]==127) {
+ I_movieSource=2;
+ midiOut.sendControlChange(1, 77, 0);
+ midiOut.sendControlChange(1, 78, 0);
+ midiOut.sendControlChange(1, 80, 0);
+ }
+ else midiOut.sendControlChange(1, 79, 127);
+ break;
+ case 80:
+ if (eventArgs.bytes[2]==127) {
+ I_movieSource=3;
+ midiOut.sendControlChange(1, 77, 0);
+ midiOut.sendControlChange(1, 78, 0);
+ midiOut.sendControlChange(1, 79, 0);
+ }
+ else midiOut.sendControlChange(1, 80, 127);
+ break;
+
+ // probably make controls logarithmic
+ case 81:
+ F_xRotate=(((float) eventArgs.bytes[2])-64)*.1;
+ break;
+ case 82:
+ F_yRotate=(((float) eventArgs.bytes[2])-64)*.1;
+ break;
+ case 83:
+ F_zRotate=(((float) eventArgs.bytes[2])-64)*.1;
+ break;
+ case 84:
+ F_drawStep=(((float) eventArgs.bytes[2])-64)*.1;
+ break;
+ case 85:
+ //F_movieSpeed=((float)eventArgs.bytes[1])/64.0;
+ F_lineWidth=((float)eventArgs.bytes[2])/8.0;
+ break;
+ case 86:
+ F_drawDecay=((float)eventArgs.bytes[2])/127.0;
+ break;
+ case 87:
+ I_fade2=((float)eventArgs.bytes[2])*2;
+ break;
+ case 88:
+ I_fade1=((float)eventArgs.bytes[2])*2;
+ //printf("fog- %f\n", F_drawDecay);
+ break;
+
+ case 90: //back
+ F_xRotation=180;
+ F_yRotation=0;
+ F_zRotation=0;
+ midiOut.sendControlChange(1, 90, 0);
+ break;
+ case 91: //top
+ F_xRotation=90;
+ F_yRotation=90;
+ F_zRotation=0;
+ midiOut.sendControlChange(1, 91, 0);
+ break;
+ case 92: //front
+ F_xRotation=180;
+ F_yRotation=180; //was 180
+ F_zRotation=180;
+ midiOut.sendControlChange(1, 92, 0);
+ break;
+
+ //89-92 bottom 4
+
+ }
+ //printf("rotation- %f %f %f\n",F_xRotate,F_yRotate,F_zRotate);
+ //printf(inputMode==PICTURE?"PICTURE mode\n":"GRABBER mode\n");
+ }
+}
+void testApp::setMidiState(){
+ int knobs[32];
+ int buttons[16];
+ int faders[8];
+ for (int i=0;i<32;i++) knobs[i]=0;
+ for (int i=0;i<16;i++) buttons[i]=0;
+ for (int i=0;i<8;i++) faders[i]=0;
+
+ knobs[0] = (F_scale * 5);
+ knobs[1]=(F_particleSize*4);
+ knobs[2]=(F_drawAxis/(360.0/127))+64;
+
+ knobs[3]=F_particleAmount/(10000.0f/127);
+ knobs[4]=F_particleLife/(5.0f/127);
+ knobs[5]=(F_particleX*.5)+64;
+ knobs[6]=(F_particleY*.5)+64;
+ knobs[7]=(F_particleZ*.5)+64;
+
+
+ //radio button set
+ buttons[0]=(visMode==FFT_AVG?127:0);
+ buttons[1]=(visMode==FFT_RAW?127:0);
+ buttons[2]=(visMode==WAVEFORM?127:0);
+
+ //radio button set
+ buttons[3]=(inputMode==PICTURE?127:0);
+ buttons[4]=(inputMode==GRABBER?127:0);
+ buttons[5]=B_glitch?127:0;
+ buttons[6]=B_fill?127:0;
+ buttons[7]=B_vSync?127:0;
+
+ buttons[12]=I_movieSource==0?127:0;
+ buttons[13]=I_movieSource==1?127:0;
+ buttons[14]=I_movieSource==2?127:0;
+ buttons[15]=I_movieSource==3?127:0;
+
+ faders[0]=(F_xRotate*10)+64;
+ faders[1]=(F_yRotate*10)+64;
+ faders[2]=(F_zRotate*10)+64;
+ faders[3]=(F_drawStep*10)+64;
+ faders[4]=F_lineWidth*8;
+
+ faders[5]=(F_drawDecay*127);
+
+ faders[6]=I_fade1/2;
+ faders[7]=I_fade1/2;
+
+ for (int i=0;i<32;i++) midiOut.sendControlChange(1, i+1, knobs[i]);
+ for (int i=0;i<16;i++) midiOut.sendControlChange(1, i+65, buttons[i]);
+ for (int i=0;i<8;i++) midiOut.sendControlChange(1, i+81, faders[i]);
+}
+
+/*
+void sendNoteOn(int channel, int id, int value);
+void sendNoteOff(int channel, int id, int value);
+void sendControlChange(int channel, int id, int value);
+*/
+
+
generated by cgit v1.2.3 (git 2.39.1) at 2025-12-06 06:50:37 +0000