initial commitHEADmaster

9 files changed, 1249 insertions, 0 deletions

diff --git a/sunkenEngine/src/layers.cpp b/sunkenEngine/src/layers.cpp
new file mode 100755
index 0000000..bd0f1ce
--- /dev/null
+++ b/sunkenEngine/src/layers.cpp
@@ -0,0 +1,229 @@
+#include "layers.h"

+

+svglayer::svglayer() {

+    xo=0;yo=0;

+}

+svglayer::svglayer(string _f)

+{

+	load(_f);

+}

+

+void svglayer::load(string _f){

+    //check if files exits

+	svg.load(_f);

+	printf("%s: %i paths\n",_f.c_str(),svg.getNumPath());

+	for (int i=0;i<svg.getNumPath();i++) {

+       fills.push_back(svg.getPathAt(i).getFillColor());

+       strokes.push_back(svg.getPathAt(i).getStrokeColor());

+	   //printf("	path %i: fill %08x stroke %08x\n",i,svg.getPathAt(i).getFillColor().getHex(),svg.getPathAt(i).getStrokeColor().getHex());

+	}

+	isLoaded= (svg.getNumPath()>0);

+}

+void svglayer::getCentre(int cx,int cy) {

+	if (svg.getNumPath()>0) {

+        xo=(cx-svg.getWidth())/2;

+        yo=(cy-svg.getHeight())/2;

+	}

+}

+

+void svglayer::draw(float a,int cx,int cy,float colShift) {

+	getCentre(cx,cy);

+	for (int i=0;i<svg.getNumPath();i++) {

+		ofColor c=fills[i]*a;

+		if (colShift>0.0f) {

+			c.setHue(fmod(c.getHue()+colShift,255.0f));

+			//printf ("shift from %f to %f\n",c.getHue(),c.getHue()+colShift);

+		}

+	    svg.getPathAt(i).setFillColor(c);

+	    svg.getPathAt(i).draw(xo,yo);

+	}

+}

+/*

+void svglayer::draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack,float colShift) {

+	getCentre(cx,cy);

+        //draw layers tinted by controllers

+	for (int i=0;i<svg.getNumPath();i++) {

+        float h=fmod(fills[i].getHue()+colShift,255.0f);

+        float ha=h/42.7; //0-5

+        int h1=(((int)ha)+2)%6;

+        int h2=h1+1;

+        float f2=ha-h1;

+        float f1=1.0f-f2;

+        //if (transparentBlack) printf("transparent black draw %f\n",(a*(((controllers[h1]*f1)+(controllers[h2]*f2))/127.0)));

+

+	    svg.getPathAt(i).setFillColor(fills[i]*a*(((controllers[h1]*f1)+(controllers[h2]*f2))/127.0));;

+	    if (!transparentBlack||(a*(((controllers[h1]*f1)+(controllers[h2]*f2))/127.0))>0.1) {

+            svg.getPathAt(i).draw(xo,yo);

+        }

+	}

+}

+*/

+

+void svglayer::draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack,float colShift) {

+	getCentre(cx,cy);

+        //draw layers grouped by controllers

+	float layerspercontroller=((float)svg.getNumPath())/6.0f;

+

+	for (int i=0;i<6;i++) {

+		//for (int j=(int)((i+1)*layerspercontroller)-1;j>(int)(i*layerspercontroller);j--) {

+		for (int j=(int)(i*layerspercontroller);j<(int)((i+1)*layerspercontroller);j++) {

+			    svg.getPathAt(j).setFillColor(fills[j]*a*(((float)controllers[5-i])/127.0f)); //try to reverse order of these

+			    if (!transparentBlack||((a*controllers[5-i])/127.0f)>0.1) {

+			    svg.getPathAt(j).draw(xo,yo);

+			}

+		}

+	}

+	//printf("counted %i layers of %i\n",(int)(6*layerspercontroller),svg.getNumPath());

+}

+

+

+svglayer::~svglayer()

+{

+    //dtor

+}

+

+//------------------------------------------------------------------------

+imglayer::imglayer() {

+    //sprite.setUseTexture(false);

+}

+imglayer::imglayer(string _filename,int _frames,int _start,float _rate,int n, int e){

+	load(_filename,_frames,_start,_rate,n,e);

+}

+

+void imglayer::load(string _filename,int _frames,int _start,float _rate,int n, int e){

+    startNote=n;

+    endNote=e;

+	sprite.load(_filename,_frames,_start);

+	sprite.setFrameRate(_rate);

+}

+

+

+void imglayer::draw(float a,int cx,int cy,float colShift) {

+    //if (sprite.isAllocated()) if (!sprite.isUsingTexture()) sprite.setUseTexture(true); //has to be done from the main thread? still doesn't work

+

+	sprite.update();

+	int x,y,w,h;

+	if ((((float)cx)/cy)<(((float)sprite.getWidth())/sprite.getHeight())){

+		x=0;

+		w=cx;

+		h=((float)cx)*(((float)sprite.getHeight())/sprite.getWidth());

+		y=(cy-h)/2;

+	}

+	else {

+		y=0;

+		h=cy;

+		w=((float)cy)*(((float)sprite.getWidth())/sprite.getHeight());

+		x=(cx-w)/2;

+	}

+	ofEnableAlphaBlending();

+	sprite.draw(x,y,w,h);

+	ofDisableAlphaBlending();

+}

+

+void imglayer::draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack=false,float colShift=0.0f) {

+    imglayer::draw(a,cx,cy,colShift);

+}

+

+void imglayer::setNote(int note)

+{

+    //is called rerpeatedly no startNote,endNote

+    //printf("note %i (%i - %i)\n",note,startNote,endNote);

+	if ((startNote<=note)&&(endNote>=note)) {

+		if (!sprite.getIsPlaying()) {

+

+			sprite.play();

+

+		}

+		//printf("triggered frame %i of %i\n",(int)(((((float)note-startNote)/((float)endNote-startNote)))*sprite.getTotalFrames()),sprite.getTotalFrames());

+		sprite.setCurrentFrame((int)(((((float)note-startNote)/((float)endNote-startNote)))*sprite.getTotalFrames()));

+		//printf("movie %i (%i - %i) frame: %i\n",note,startNote,endNote,(int)(((((float)note-startNote)/((float)endNote-startNote)))*mov.getTotalNumFrames()));

+	}

+	else {

+	if (sprite.getIsPlaying()) {

+		sprite.stop();

+	}

+	}

+

+};

+

+

+imglayer::~imglayer()

+{

+    //sprite.setUseTexture(false); //free texture

+}

+//------------------------------------------------------------------------

+videolayer::videolayer() {

+    //sprite.setUseTexture(false);

+}

+videolayer::videolayer(string _f,int n,int e,float s)

+{

+    startNote=n;

+    endNote=e;

+	speed=s;

+	load(_f);

+}

+

+void videolayer::load(string _f){

+	name=_f;

+	mov.setPixelFormat(OF_PIXELS_BGRA);

+	mov.setUseTexture(false);

+	bool success=mov.loadMovie(_f);

+	if (success) {

+		mov.stop();

+	}

+	printf("%s %s %i bpp\n",success?"loaded":"not loaded",_f.c_str(),success?mov.getPixelsRef().getBytesPerPixel():0);

+}

+

+void videolayer::draw(float a,int cx,int cy,float colShift) {

+    if (mov.isPlaying()) {

+        mov.update();

+	//unsigned char *pix=mov.getPixels();

+	//for (int i=0;i<mov.getWidth()*mov.getHeight()*4;i+=4) pix[i+3]=(pix[i]>>2)+(pix[i+1]>>1)+(pix[i+2]>>2);

+	int x,y,w,h;

+	if ((((float)cx)/cy)<(((float)mov.getWidth())/mov.getHeight())){

+		x=0;

+		w=cx;

+		h=((float)cx)*(((float)mov.getHeight())/mov.getWidth());

+		y=(cy-h)/2;

+	}

+	else {

+		y=0;

+		h=cy;

+		w=((float)cy)*(((float)mov.getWidth())/mov.getHeight());

+		x=(cx-w)/2;

+	}

+	ofEnableAlphaBlending();

+	mov.draw(x,y,w,h);

+	ofDisableAlphaBlending();

+    }

+}

+

+void videolayer::draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack=false,float colShift=0.0f) {

+    draw(a,cx,cy,colShift);

+}

+

+void videolayer::setNote(int note)

+{

+

+	if ((startNote<=note)&&(endNote>=note)) {

+		if (!mov.isPlaying()) {

+			//printf("starting movie!\n");

+			mov.setUseTexture(true);

+			mov.play();

+			mov.setSpeed(speed);

+		}

+		mov.setFrame((int)(((((float)note-startNote)/((float)endNote-startNote)))*mov.getTotalNumFrames()));

+		//printf("movie %i (%i - %i) frame: %i\n",note,startNote,endNote,(int)(((((float)note-startNote)/((float)endNote-startNote)))*mov.getTotalNumFrames()));

+	}

+	else {

+	if (mov.isPlaying()) {

+		mov.stop();

+	}

+	}

+

+};

+

+

+videolayer::~videolayer()

+{

+}

diff --git a/sunkenEngine/src/layers.h b/sunkenEngine/src/layers.h
new file mode 100755
index 0000000..d34664a
--- /dev/null
+++ b/sunkenEngine/src/layers.h
@@ -0,0 +1,134 @@
+#ifndef SVGLAYER_H

+#define SVGLAYER_H

+

+#include "ofxSVGTiny.h"

+#include "ofMain.h"

+#include "ofxSprite.h"

+

+#include <math.h>

+

+class layer

+{

+	public:

+		layer(){};

+		layer(string _f) {load(_f);};

+		virtual ~layer(){};

+		virtual void load(string _f){};

+		virtual void draw(float a,int cx,int cy,float colShift){};

+		virtual void draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack=false,float colShift=0.0f){ draw(a,cx,cy,colShift);};

+		bool getLoaded() {return isLoaded;};

+		virtual void setNote(int note) {};

+		string name;

+		int startNote,endNote;

+	protected:

+		bool isLoaded;

+	private:

+

+};

+

+class svglayer: public layer

+{

+	public:

+		svglayer();

+		svglayer(string _f);

+		virtual ~svglayer();

+		void load(string _f);

+		void draw(float a,int cx,int cy,float colShift);

+		void draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack=false,float colShift=0.0f);

+		void getCentre(int cx,int cy);

+	protected:

+	private:

+		ofxSVGTiny svg;

+		vector <ofColor> fills;

+		vector <ofColor> strokes;

+		float xo,yo;

+};

+

+class sunkenSprite: public ofxSprite {

+	public:

+        float playhead,frameRate;

+	void setFrameRate(float frameRate) { this->frameRate = frameRate;};

+        void play() {

+            startTime=ofGetElapsedTimef();

+            ofxSprite::play();

+        }

+        void update() {

+            if (!getIsPlaying()) return;

+		 playhead=fmod(speed * frameRate * (ofGetElapsedTimef()-startTime),(float)getTotalFrames());

+            ofxSprite::setCurrentFrame(playhead);

+

+        }

+        void setCurrentFrame(float frame) {

+		//this idea doesn't work - fucks up when frameRate is 0 - 

+		//need to rethink

+		

+		//when frameRate is 0 startTime doesn't matter

+		//this still might not be not entirely correct

+		if (frameRate>0)  startTime-=(frame-pos) / ((float)(frameRate * speed ));

+	 //printf("sunkensprite setting frame %i of %i\n",(int)frame,getTotalFrames());

+		//printf("1 checking frame %i of %i\n",(int)frame,getTotalFrames());

+            ofxSprite::setCurrentFrame(frame);

+		/*

+		    pos = frame;

+		printf("2 checking frame %i of %i\n",(int)frame,getTotalFrames());

+    printf("requesting movie frame %i of %i\n",(int)pos,getTotalFrames());

+    if (pos<0) if (loop) { pos += totalFrames; } else stop();

+    if (pos>=totalFrames) if (loop) {

+	    while (pos>=totalFrames) pos -= totalFrames;

+	} else { pos = totalFrames-.00001f; isPlaying=false; }

+	printf("set movie frame %i of %i\n",(int)pos,totalFrames);

+		*/

+        }

+        void draw(int x,int y,int w,int h) {

+

+            int f=playhead;

+            float fr=fmod(playhead,1.0f);

+            ofSetColor(255,255,255,(1.0-fr)*255);

+            	//not always?

+            getImageAtFrame(f).setUseTexture(true);

+            //getImageAtFrame(f).reloadTexture(); ->190315 still necessary?

+            getImageAtFrame(f).draw(x,y,w,h);

+            ofSetColor(255,255,255,fr*255);

+		f=(f+1)%getTotalFrames();

+             getImageAtFrame(f).setUseTexture(true);

+            //getImageAtFrame(f).reloadTexture(); ->190315 still necessary?

+            getImageAtFrame(f).draw(x,y,w,h);

+        }

+

+	private:

+        float startTime;

+        float speed,pos; //will this override the base class speed correctly?

+

+};

+

+class imglayer: public layer

+{

+	public:

+		imglayer();

+		imglayer(string _f,int _frames=1,int _start=1,float _rate=0,int note=0,int endnote=0);

+		virtual ~imglayer();

+		void load(string _filename,int _frames=1,int _start=1,float _rate=0.0,int note=0,int endnote=0);

+		void draw(float a,int cx,int cy,float colShift);

+		void draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack,float colShift);

+		void setNote(int n);

+	protected:

+	private:

+		sunkenSprite sprite;

+};

+

+class videolayer: public layer

+{

+	public:

+		videolayer();

+		videolayer(string _f,int n,int e,float s);

+		virtual ~videolayer();

+		void load(string _f);

+		void draw(float a,int cx,int cy,float colShift);

+		void draw(float a,unsigned char* controllers,int cx,int cy,bool transparentBlack,float colShift);

+		void setNote(int n);

+    protected:

+	private:

+		float speed;

+		ofVideoPlayer mov;

+};

+#endif // SVGLAYER_H

diff --git a/sunkenEngine/src/main.cpp b/sunkenEngine/src/main.cpp
new file mode 100644
index 0000000..6d5ff5c
--- /dev/null
+++ b/sunkenEngine/src/main.cpp
@@ -0,0 +1,62 @@
+#include "ofMain.h"
+#include "ofApp.h"
+#include "ofAppGLFWWindow.h"
+
+//========================================================================
+int main( ){
+
+	if (false){
+
+		ofSetupOpenGL(1360,256, OF_WINDOW);
+		ofRunApp( new ofApp());
+	}
+	else {
+
+		ofGLFWWindowSettings settings;
+		settings.width = 2560; //1280; //
+		settings.height = 720; //360; //
+		settings.position.x = 0;
+		settings.position.y = 50;
+		settings.resizable = true;
+
+		shared_ptr<ofAppBaseWindow> mainWindow = ofCreateWindow(settings);
+
+
+		settings.width = 600;
+		settings.height = 800;
+		settings.position.x = 300;
+		settings.position.y = 400;
+		settings.resizable = true;
+		settings.shareContextWith = mainWindow; //YES
+
+		shared_ptr<ofAppBaseWindow> previewWindow = ofCreateWindow(settings);
+		previewWindow->setVerticalSync(false);
+		//previewWindow->showCursor();
+
+
+		settings.width = 224;
+		settings.height = 480;
+		settings.position.x = 0;
+		settings.position.y = 400;
+		settings.resizable = false;
+		shared_ptr<ofAppBaseWindow> guiWindow = ofCreateWindow(settings);
+		guiWindow->setVerticalSync(false);
+
+		
+		shared_ptr<ofApp> mainApp(new ofApp);
+		mainApp->setupGui();
+
+		ofAddListener(guiWindow->events().draw,mainApp.get(),&ofApp::drawGui);
+		ofAddListener(guiWindow->events().fileDragEvent,mainApp.get(),&ofApp::dragGui);
+		ofAddListener(guiWindow->events().keyPressed,mainApp.get(),&ofApp::keyPreview);
+
+		ofAddListener(previewWindow->events().draw,mainApp.get(),&	ofApp::drawPreview);
+		ofAddListener(previewWindow->events().keyPressed,mainApp.get(),&ofApp::keyPreview);
+		ofAddListener(previewWindow->events().mouseDragged,mainApp.get(),&ofApp::previewMousePressedEvent);
+
+
+		ofRunApp(mainWindow, mainApp);
+		ofRunMainLoop();
+	}
+
+}
diff --git a/sunkenEngine/src/ofApp.cpp b/sunkenEngine/src/ofApp.cpp
new file mode 100644
index 0000000..2c3b2f3
--- /dev/null
+++ b/sunkenEngine/src/ofApp.cpp
@@ -0,0 +1,378 @@
+#include "ofApp.h"
+
+//--------------------------------------------------------------
+void ofApp::setup(){
+
+	//setupGui();
+
+	int midiPort=0;
+	midiChannel=0;
+	if( !XML.loadFile("settings_parlour.xml") ){ //_onscreen
+		printf("unable to load settings.xml check data/ folder\n");
+	}else{
+		printf("settings loaded!\n");
+		midiPort=ofToInt(XML.getAttribute("liveEngine", "port", "0")); //default to 0/all
+		midiChannel=ofToInt(XML.getAttribute("liveEngine", "channel", "0"));
+		if (midiChannel) printf("listening on port %d, midi channel %d\n",midiPort,midiChannel);
+		else printf("listening on port %d, all midi channels\n",midiPort);
+		if(XML.pushTag("liveEngine")) {
+            int numViews=XML.getNumTags("viewport");
+            if(numViews) {
+                for (int i=0;i<numViews;i++) {
+                    int w=XML.getAttribute("viewport", "w",0,i);
+                    int h=XML.getAttribute("viewport", "h",0,i);
+                    int x=XML.getAttribute("viewport", "x",0,i);
+                    int y=XML.getAttribute("viewport", "y",0,i);
+                    int rot=XML.getAttribute("viewport", "rot",0,i);
+                    int ox=XML.getAttribute("viewport", "ox",0,i);
+                    int oy=XML.getAttribute("viewport", "oy",0,i);
+                    printf("viewport %i: %ix%i\n",i,w,h);
+                    viewports.push_back(new viewport(w,h,x,y,rot,ox,oy));
+                }
+            }
+            else printf("no viewports!\n");
+		}
+	}
+
+	printf("screen %ix%i\n",ofGetHeight(),ofGetWidth());
+
+	// print input ports to console
+	midiIn.listPorts();
+	midiIn.openPort(midiPort);
+	midiIn.addListener(this);
+
+	controllers=new unsigned char[NUM_CONTROLLERS];
+	memset(controllers,NUM_CONTROLLERS,0);
+	note=0;
+
+	makeColours();
+
+	colShift=0;
+
+	controlColours=false;
+	noteRandomiseColours=false;
+	transparentBlack=false;
+	reversemain=false;
+
+	showFPS=false;
+	ofBackground(0,0,0);
+
+	ofSetBackgroundAuto(false);
+
+	xshift=-1;
+	yshift=-1;
+
+	fadetime=0;
+
+	mode=BLOCKS;
+
+	lastnoteTime=ofGetElapsedTimef();
+	decayTime=1.0f;
+
+	//ofSetVerticalSync(true); deosn't seem effective
+	//glXSwapIntervalSGI(1);
+
+	ofSetFrameRate(60);
+	rotate=-90;
+	scale=1.0f;
+	fscale=1.0f;
+
+	previewBuffer=&(viewports[1]->rb1);
+
+}
+
+
+void ofApp::resetDrawscalePressed(bool & pressed){
+	scale=1.0f;
+}
+void ofApp::resetFBscalePressed(bool & pressed){
+	fscale=1.0f;
+}
+//--------------------------------------------------------------
+void ofApp::setupGui(){
+	parameters.setName("parameters");
+
+	parameters.add(reverse.set("reverse", false));
+	parameters.add(reversemain.set("reverse main", false));
+	parameters.add(controlColours.set("control colours", false));
+	parameters.add(noteRandomiseColours.set("randomise note colours", false));
+	parameters.add(transparentBlack.set("transparent black", false));
+	parameters.add(resetDrawscale.set("reset draw scale",false));
+	parameters.add(resetFBscale.set("reset FB scale",false));
+	parameters.add(fadeScale.set("fade scale",0,0,255));
+	parameters.add(fadeBackground.set("decay background",255,0,255));
+	parameters.add(decayTime.set("decay time",0,0,10.0f));
+	parameters.add(oscScale.set("scale size LFO", false));
+	parameters.add(breakOsc.set("break oscillators", false));
+	parameters.add(randomOsc.set("randomise oscillators", false));
+	parameters.add(scaleAmplitude.set("fade scale",0,0,2.0f));
+	parameters.add(scaleFrequency.set("fade freq",0,0,5.0f));
+	gui.setup(parameters);
+
+	resetDrawscale.addListener(this,&ofApp::resetDrawscalePressed);
+	resetFBscale.addListener(this,&ofApp::resetFBscalePressed);
+	
+	ofSetBackgroundColor(0);
+	
+}
+
+void ofApp::makeColours() {
+	controller_colours=new ofColor[NUM_CONTROLLERS];
+	for (int i=0;i<NUM_CONTROLLERS;i++) controller_colours[i]=ofColor::fromHsb(ofRandom(255), 255, 255);
+	colShift=ofRandom(255.0f);
+}
+
+//--------------------------------------------------------------
+void ofApp::update(){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::draw(){
+
+	float lambda=max(0.0f,1.0f-((ofGetElapsedTimef()-lastnoteTime)/decayTime));
+
+	int ft=255-(fadetime*((float)fadeScale)*0.1f);
+	//if(ofGetFrameNum()%25==0) printf("fadeScale %i\n",(int)fadeScale);
+	ofSetColor(ft,ft,ft); //for feedback
+
+	float os=oscScale?(sin((breakOsc?ofGetElapsedTimef()-(randomOsc?randOffs:lastnoteTime):ofGetElapsedTimef()))*scaleFrequency)*scaleAmplitude:0.0f;
+	//vp1.draw(lambda,controllers,xshift,yshift,list,transparentBlack,note,mode,controller_colours,controlColours,scale,fscale,noteRandomiseColours?colShift:0.0f);
+	//vp2.draw(lambda,controllers,reversemain?-xshift:xshift,yshift,list,transparentBlack,note,mode,controller_colours,controlColours,reversemain?1.0f/scale:scale,reversemain?1.0f/fscale:fscale,noteRandomiseColours?colShift:0.0f);
+	for (int i=0;i<viewports.size();i++) {
+		bool even=!(i%2);
+		bool do_reverse=reverse?!(even&&reversemain):even&&reversemain;
+		viewports[i]->draw(lambda,controllers,do_reverse?-xshift:xshift,yshift,list,transparentBlack,note,mode,controller_colours,controlColours,do_reverse?1.0f/(scale+os):scale+os,do_reverse?1.0f/fscale:fscale,noteRandomiseColours?colShift:0.0f,fadeBackground);
+	}
+
+	ofSetColor(255,255,255);
+	if (showFPS) ofDrawBitmapString(ofToString(ofGetFrameRate(), 2),20,20);
+
+}
+
+void ofApp::drawPreview(ofEventArgs & args){
+	//ofBackground(0);
+	previewBuffer->draw(0,0,ofGetWidth(),ofGetHeight()); 
+
+}
+
+//--------------------------------------------------------------
+void ofApp::drawGui(ofEventArgs & args){
+	gui.draw();
+
+	if (list.lock()) { //if loaded
+		if (!list.thumbnailed) list.makeThumbnail();
+		if (list.thumbnailed) list.thumbnail.draw(20,ofGetHeight()-150);
+		list.unlock();
+	}
+	ofDrawBitmapString(list.name,20,ofGetHeight()-10);
+	
+}
+
+void ofApp::dragGui(ofDragInfo & dragInfo){
+	printf("got draginfo: %s\n",dragInfo.files[0].c_str());
+    int sta=dragInfo.files[0].find_last_of("\\/")+1;
+    int len=(dragInfo.files[0].find_last_of(".")+4)-sta;
+	string filename="images/"+dragInfo.files[0].substr(sta,len);
+	printf("loading %s\n",filename.c_str());
+
+	list.load(filename);
+}
+
+//--------------------------------------------------------------
+void ofApp::keyPressed(int key){
+	cerr<<"key: "<<key<<endl;
+	switch(key){
+		case ' ':
+			fullscreenoutput=!fullscreenoutput;
+			ofSetFullscreen(fullscreenoutput);
+			printf("resolution: %ix%i %s\n",ofGetWidth(),ofGetHeight(),fullscreenoutput?"fullscreen":"windowed");
+		break;
+	}
+
+}
+
+void ofApp::keyPreview(ofKeyEventArgs& eventArgs){
+	//cerr<<"key: "<<eventArgs.key<<endl;
+
+	int key=eventArgs.key;
+		if(key =='q'){
+			nmidiMessage(144,127,ofRandom(64)+36);
+		}
+		if(key == 's'){
+			XML.saveFile("settings.xml");
+			printf("settings saved!\n");
+		}
+		if(key == 'f'){
+			toggleFPS();
+		}
+		if(key >='0' && key <= '9'){
+			mode=key-'0';
+		}
+		if(key == 267||key==OF_KEY_LEFT){
+			xshift--;
+		}
+		if(key == 268||key==OF_KEY_RIGHT){
+			xshift++;
+		}
+		if(key == 269||key==OF_KEY_UP){
+			yshift--;
+		}
+		if(key == 270||key==OF_KEY_DOWN){
+			yshift++;
+		}
+		if(key == '='){
+			makeColours();
+		}
+		 if(key == '+'){
+			fadetime=min(128,fadetime+1);
+		}
+		if(key == '_'){
+			fadetime=max(0,fadetime-1);
+		}
+		if(key == ']'){
+			scale*=1.01;
+		}
+		if(key == '['){
+			scale/=1.01;
+		}
+		if(key == '}'){
+			rotate+=90;
+		}
+		if(key == '{'){
+			rotate-=90;
+		}
+
+
+		if(key == 'd'){
+			debug=!debug;
+		}
+
+		if (key=='j') {
+		    fscale=1.0f;
+		}
+		if (key=='h') {
+		    scale=1.0f;
+		}
+
+}
+
+//--------------------------------------------------------------
+void ofApp::keyReleased(int key){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseMoved(int x, int y ){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseDragged(int x, int y, int button){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::mousePressed(int x, int y, int button){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::mouseReleased(int x, int y, int button){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::windowResized(int w, int h){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::gotMessage(ofMessage msg){
+
+}
+
+//--------------------------------------------------------------
+void ofApp::dragEvent(ofDragInfo dragInfo){ 
+
+}
+
+void ofApp::toggleFPS(){
+	showFPS=!showFPS;
+}
+
+void ofApp::newMidiMessage(ofxMidiMessage& eventArgs){
+    if ((midiChannel==0)||(eventArgs.channel==midiChannel)) {
+        nmidiMessage(eventArgs.status,eventArgs.bytes[2],eventArgs.bytes[1]);
+    }
+}
+
+    //newMessage(eventArgs.port, eventArgs.channel, eventArgs.byteTwo, eventArgs.timestamp);
+
+//byteOne : message type
+
+    /*
+    int 	port;
+	int		channel;
+	int 	status;
+	int 	byteOne;
+	int 	byteTwo;
+	double 	timestamp;
+	*/
+
+    //printf("%d %d %d %d %d\n",eventArgs.port,eventArgs.channel,eventArgs.status,eventArgs.byteOne,eventArgs.byteTwo);
+void ofApp::nmidiMessage(int event,int data1, int data2) {
+    //printf("midi: %i %i %i\n",event,data1,data2);
+    bool noteOn; //this old thing!
+    int i;
+        switch(event) {
+            case 144: //noteon-off channel 0
+           //printf("note %i %i %i\n",event,data1,data2);
+                noteOn=(data1==0?false:true);
+                //for (int i=0;i<numLayers;i++){
+                //    if (layers[i]->note==eventArgs.byteOne) layers[i]->setActive(noteOn);
+                //}
+
+                note=data2;
+                lastnoteTime=ofGetElapsedTimef();
+                if (list.layers.size()&&list.lock()) { //if playlist is loaded
+					map<int, layer*>::iterator itr;
+					//for(itr = list.layers.begin(); itr != list.layers.end(); ++itr){
+					//	list.layers[itr->first]->setNote(note);
+					//}
+					if (list.layers.find(note)!=list.layers.end()) list.layers[note]->setNote(note);
+					list.unlock();
+				}
+			if (noteRandomiseColours) {
+				makeColours(); //
+			}
+			randOffs=ofRandom(100.0f);
+             break;
+            case 176: //control change channel 0
+                //for (int i=0;i<numLayers;i++){
+                //    if (layers[i]->mix==eventArgs.byteOne) layers[i]->setMixAmt(((float)eventArgs.byteTwo)/127.0f);
+                //}
+            	//maybe the CC are coming in <127?
+                //if (debug) 
+                //printf("cc: %i %i\n",data1,data2);
+                if (data2>=START_CONTROLLER&&data2<(NUM_CONTROLLERS-START_CONTROLLER)) controllers[data2-START_CONTROLLER]=data1;
+        }
+
+}
+void ofApp::previewMousePressedEvent(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:
+			xshift=args.x-(ofGetWidth()/2);
+			yshift=args.y-(ofGetHeight()/2);
+			break;
+		case 1:
+			//cerr<<""
+			scale=pow((float)pow((float)args.x-(ofGetWidth()/2),2.0f)+pow((float)args.y-(ofGetHeight()/2),2),0.5f)/(ofGetWidth()*.1);
+			break;
+		case 2:
+			fscale=(pow((float)pow((float)args.x-(ofGetWidth()/2),2.0f)+pow((float)args.y-(ofGetHeight()/2),2),0.5f)/(ofGetWidth()))+0.5;
+			break;
+	}
+}
\ No newline at end of file
diff --git a/sunkenEngine/src/ofApp.h b/sunkenEngine/src/ofApp.h
new file mode 100644
index 0000000..04f63dd
--- /dev/null
+++ b/sunkenEngine/src/ofApp.h
@@ -0,0 +1,119 @@
+#pragma once
+
+#include "ofMain.h"
+#include "ofxGui.h"
+#include "ofxXmlSettings.h"
+#include "ofxMidi.h"
+
+#include "viewport.h"
+
+class ofApp : public ofBaseApp, public ofxMidiListener{
+
+	public:
+		void setup();
+		void setupGui();
+		void update();
+		void draw();
+		void drawGui(ofEventArgs & args);
+		void dragGui(ofDragInfo & dragInfo);
+		void previewMousePressedEvent(ofMouseEventArgs &args);
+
+		void keyPressed(int key);
+		void keyReleased(int key);
+		void mouseMoved(int x, int y );
+		void mouseDragged(int x, int y, int button);
+		void mousePressed(int x, int y, int button);
+		void mouseReleased(int x, int y, int button);
+		void windowResized(int w, int h);
+		void dragEvent(ofDragInfo dragInfo);
+		void gotMessage(ofMessage msg);
+
+		void newMidiMessage(ofxMidiMessage& eventArgs);
+
+		bool fullscreenoutput;
+
+
+		void nmidiMessage(int event,int data1, int data2);
+		
+
+		void makeColours();
+
+		void toggleFPS();
+		bool showFPS;
+
+		
+		ofxXmlSettings XML;
+
+		unsigned char* controllers;
+		int note, mode;
+
+        //to be moved into svg object gui
+		bool debug;
+
+		
+
+		float lastnoteTime;
+
+		int fadetime;
+		int rotate;
+		float scale,fscale;
+
+		int xshift,yshift;
+
+		ofColor* controller_colours;
+
+		float colShift;
+
+		
+
+		viewport vp1,vp2;
+		vector<viewport*> viewports;
+
+		int midiChannel;
+
+		ofxMidiIn midiIn;
+		ofxMidiMessage midiMessage;
+
+		playlist list;
+
+
+		ofParameterGroup parameters;
+
+
+
+		ofParameter<bool> reverse;
+		ofParameter<bool> reversemain;
+		ofParameter<bool> controlColours;
+		ofParameter<bool> noteRandomiseColours;
+		ofParameter<bool> transparentBlack;
+		ofParameter<bool> resetDrawscale;
+		ofParameter<bool> resetFBscale;
+
+		ofParameter<int> fadeScale;
+		ofParameter<int> fadeBackground;
+		ofParameter<float> decayTime;
+
+		ofParameter<bool> oscScale;
+		ofParameter<bool> breakOsc;
+		ofParameter<bool> randomOsc;
+
+		ofParameter<float> scaleAmplitude;
+		ofParameter<float> scaleFrequency;
+
+
+		ofxPanel gui;
+		
+
+		float randOffs;
+
+		void resetDrawscalePressed(bool & pressed);
+		void resetFBscalePressed(bool & pressed);
+
+		void keyPreview(ofKeyEventArgs& eventArgs);
+
+		void drawPreview(ofEventArgs & args);
+		ofFbo *previewBuffer;
+
+
+
+};
diff --git a/sunkenEngine/src/playlist.cpp b/sunkenEngine/src/playlist.cpp
new file mode 100755
index 0000000..eac895f
--- /dev/null
+++ b/sunkenEngine/src/playlist.cpp
@@ -0,0 +1,127 @@
+#include "playlist.h"
+
+playlist::playlist()
+{
+	name="";
+	
+}
+
+void playlist::load(string _name){
+    //printf("loading %s\n",_name.c_str());
+	thumbnail.allocate(128,128,GL_RGB); //segfault here orig 128,128,GL_RGB
+	thumbnailed=false;
+
+    if( !XML.loadFile(_name) ){
+		printf("unable to load %s check data/ folder\n",_name.c_str());
+    }else {
+        //printf("starting loader thread\n");
+        loadimg(); //how to do this from the worker thread???
+        startThread(false, false); //blocking, verbose
+    }
+
+
+
+}
+
+void playlist::threadedFunction(){
+        if( lock() ){
+            loadLayers();
+            unlock();
+            printf("unlocking thread\n");
+        }
+}
+
+void playlist::loadLayers(){
+	int numLayers=0;
+	layers.clear();
+	name=XML.getAttribute("playlist", "name", "");
+	float speed=XML.getAttribute("playlist", "speed", 0);
+	if(XML.pushTag("playlist")) {
+		numLayers=XML.getNumTags("svglayer");
+		if(numLayers) {
+			for (int i=0;i<numLayers;i++) {
+				string s=XML.getAttribute("svglayer", "file", "",i);
+				printf("loading %s: \n",s.c_str());
+				layers[XML.getAttribute("svglayer", "note", 0,i)]=new svglayer(s);
+			}
+			thumbnailed=false;
+		}
+		numLayers=XML.getNumTags("movlayer");
+		if(numLayers) {
+			for (int i=0;i<numLayers;i++) {
+				string s=XML.getAttribute("movlayer", "file", "",i);
+				printf("loading %s: \n",s.c_str());
+				int note=XML.getAttribute("movlayer", "note", 0,i);
+				int endnote=XML.getAttribute("movlayer", "endnote", 0,i);
+				layers[note]=new videolayer(XML.getAttribute("movlayer", "file", "",i),note,endnote,speed);
+				if (endnote>note) {
+					for (int j=note+1;j<endnote;j++) {
+						layers[j]=layers[note];
+					    }
+				}
+			}
+			thumbnailed=false;
+		}
+		numLayers=XML.getNumTags("imglayer");
+		if(numLayers) {
+			for (int i=0;i<numLayers;i++) {
+				string s=XML.getAttribute("imglayer", "files", "",i);
+				printf("loading %s: \n",s.c_str());
+				int note=XML.getAttribute("imglayer", "note", 0,i);
+				int endnote=XML.getAttribute("imglayer", "endnote", 0,i);
+				float rate=XML.getAttribute("imglayer", "rate", 0.0,i);
+				int frames=XML.getAttribute("imglayer", "frames", 0,i);
+				int start=XML.getAttribute("imglayer", "start", 1,i);
+				layers[note]=new imglayer(s,frames,start,rate,note,endnote);
+				if (endnote>note) {
+					for (int j=note+1;j<=endnote;j++) {
+						layers[j]=layers[note];
+					    }
+				}
+			}
+			thumbnailed=false;
+		}
+		XML.popTag();
+	}
+
+}
+
+void playlist::makeThumbnail(){
+	if (layers.size()) {
+		thumbnail.begin();
+		ofBackground(0,0,0);
+		ofPushMatrix();
+		ofTranslate(64,64);
+		ofScale(0.2,0.2,0.2);
+		ofTranslate(-64,-64);
+		map<int,layer*>::iterator i=layers.begin();
+		i->second->draw(1.0,64,64,0.0);
+		ofPopMatrix();
+		thumbnail.end();
+		thumbnailed=true;
+	}
+}
+
+
+void playlist::loadimg(){
+    int numLayers=0;
+    layers.clear();
+    if(XML.pushTag("playlist")) {
+      numLayers=XML.getNumTags("imglayer");
+          if(numLayers) {
+                 for (int i=0;i<numLayers;i++) {
+             string s=XML.getAttribute("imglayer", "file", "",i);
+             printf("%s: ",s.c_str());
+            layers[XML.getAttribute("imglayer", "note", 0,i)]=new imglayer(XML.getAttribute("imglayer", "file", "",i));
+         }
+          }
+      else printf("no IMG layers loaded!\n");
+      XML.popTag();
+     }
+
+}
+
+playlist::~playlist()
+{
+    //dtor
+}
diff --git a/sunkenEngine/src/playlist.h b/sunkenEngine/src/playlist.h
new file mode 100755
index 0000000..e672260
--- /dev/null
+++ b/sunkenEngine/src/playlist.h
@@ -0,0 +1,30 @@
+#ifndef PLAYLIST_H

+#define PLAYLIST_H

+

+#include "ofThread.h"

+#include "ofxXmlSettings.h"

+

+#include "layers.h"

+#include "ofMain.h"

+

+class playlist : public ofThread {

+    public:

+        playlist();

+        virtual ~playlist();

+        void loadimg();

+        void loadLayers();

+        void load(string _name);

+        void threadedFunction();

+        void makeThumbnail();

+

+        ofFbo thumbnail;

+        bool thumbnailed;

+

+        ofxXmlSettings XML;

+        map<int,layer*> layers;

+        string name;

+    protected:

+    private:

+};

+

+#endif // PLAYLIST_H

diff --git a/sunkenEngine/src/viewport.cpp b/sunkenEngine/src/viewport.cpp
new file mode 100755
index 0000000..a169146
--- /dev/null
+++ b/sunkenEngine/src/viewport.cpp
@@ -0,0 +1,136 @@
+#include "viewport.h"

+

+

+

+viewport::viewport()

+{

+    //ctor

+}

+viewport::viewport(int _w,int _h,int _x,int _y,float _r,int _ox,int _oy) {

+	setup(_w,_h,_x,_y,_r,_ox,_oy);

+}

+

+void viewport::setup(int _w,int _h,int _x,int _y,float _r,int _ox,int _oy) {

+	r=_r;

+	w=_w;

+	h=_h;

+	x=_x;

+	y=_y;

+	ox=_ox;

+	oy=_oy;

+	rb1.allocate(w,h,GL_RGB);

+	rb2.allocate(w,h,GL_RGB);

+

+	printf("%ix%i, vp offset: %f,%f\n",w,h,-(sin(ofDegToRad(r))*h/2)-(cos(ofDegToRad(r))*w/2),-(sin(ofDegToRad(r))*w/2)-(cos(ofDegToRad(r))*h/2));

+}

+

+void viewport::draw(float a,unsigned char* controllers,int xshift,int yshift,playlist &list,bool transparentBlack,int note,int mode,ofColor* controller_colours,bool controlColours,float scale,float fscale,float colShift,int fadeBG){

+	

+	//http://forum.xfce.org/viewtopic.php?id=6580

+		

+		// test screen shape

+		/*

+		ofSetColor(255,0,0);

+		ofRect(0,0,w/2,h/2);

+		ofRect(w/2,h/2,w/2,h/2);

+		ofSetColor(0,255,0);

+		ofRect(0,h/2,w/2,h/2);

+		ofRect(w/2,0,w/2,h/2);

+		*/

+

+		ofPushMatrix();

+		

+		rb1.begin();

+

+		//can be done with texture offset?

+

+		int startx=((w-(w*fscale))/2)+xshift;

+		while (startx>0) startx-=(w*fscale);

+		int starty=((h-(h*fscale))/2)+yshift;

+		while (starty>0) starty-=(h*fscale);

+		

+		for (int i=startx;i<w*2;i+=(w*fscale)) {

+			for (int j=starty;j<h*2;j+=(h*fscale)) {

+			    rb2.draw(i,j,w*fscale,h*fscale);

+			}

+		}

+

+		if (fadeBG>0) {

+			//fadeout part

+			ofEnableAlphaBlending();

+			ofSetColor(0,0,0,fadeBG);

+			ofRect(0,0,w,h);

+			ofDisableAlphaBlending();

+		}

+

+		float notewidth=w/NUM_NOTES;

+		float noteheight=h/NUM_CONTROLLERS;

+

+		ofPushStyle();

+

+			if (note>0) {

+				switch(mode) {

+					case BLOCKS:

+						for (int i=0;i<NUM_CONTROLLERS;i++){

+						ofSetColor(ofColor((controller_colours[i].r*controllers[i])>>7,(controller_colours[i].g*controllers[i])>>7,(controller_colours[i].b*controllers[i])>>7));

+						ofRect((note-START_NOTE)*notewidth,i*noteheight,notewidth,noteheight);

+						}

+						break;

+					case LIST:

+				if (list.lock()) { //if playlist is loaded

+				    if (list.layers.find(note)!=list.layers.end()) {

+					ofPushMatrix();

+					ofTranslate(w/2,h/2);

+					ofScale(scale,scale,scale);

+					ofTranslate(-w/2,-h/2);

+					ofSetColor(255,255,255);

+					if (controlColours) list.layers[note]->draw(a,controllers,w,h,transparentBlack,colShift);

+					else list.layers[note]->draw(a,w,h,colShift);

+					ofPopMatrix();

+				    }

+				    list.unlock();

+				}

+						break;

+				}

+			}

+

+			ofPopStyle();

+

+			rb1.end();

+

+			rb2.begin();

+			ofSetColor(255,255,255);

+			rb1.draw(0,0);

+			rb2.end();

+

+			ofPopMatrix();

+			

+			ofPushMatrix();

+			//ofTranslate(x+(w/2),y+(h/2)); this was the one that was working

+			//ofTranslate(abs(sin(ofDegToRad(r))*h/2)+abs(cos(ofDegToRad(r))*w/2),abs(sin(ofDegToRad(r))*w/2)+abs(cos(ofDegToRad(r))*h/2));

+			ofTranslate(x,y);

+

+			ofTranslate(((w/2)*abs(cos(ofDegToRad(r))))+((h/2)*abs(sin(ofDegToRad(r)))),

+				((w/2)*abs(sin(ofDegToRad(r))))+((h/2)*abs(cos(ofDegToRad(r)))));

+

+			ofRotate(r);

+			ofTranslate(-w/2,-h/2);

+			//ofTranslate(-abs(sin(ofDegToRad(r))*h/2)-abs(cos(ofDegToRad(r))*w/2),-abs(sin(ofDegToRad(r))*w/2)-abs(cos(ofDegToRad(r))*h/2));

+			//ofTranslate(ox,oy); get rid of this and get the rotation right

+			

+			ofDisableAlphaBlending();

+

+			rb2.draw(0,0);	

+

+			ofPopMatrix();

+			

+		

+	

+	

+

+}

+

+viewport::~viewport()

+{

+    //dtor

+}

diff --git a/sunkenEngine/src/viewport.h b/sunkenEngine/src/viewport.h
new file mode 100755
index 0000000..e28a347
--- /dev/null
+++ b/sunkenEngine/src/viewport.h
@@ -0,0 +1,34 @@
+#ifndef VIEWPORT_H

+#define VIEWPORT_H

+

+#include "ofMain.h"

+#include "playlist.h"

+

+#define NUM_NOTES 64

+#define START_NOTE 36

+#define NUM_CONTROLLERS 120

+#define START_CONTROLLER 102

+

+#define NOTHING 0

+#define BLOCKS 1

+#define LIST 2

+

+

+

+class viewport

+{

+    public:

+	viewport();

+	viewport(int _w,int _h,int _x,int _y,float _r,int _ox,int _oy);

+        void setup(int _w,int _h,int _x,int _y,float _r,int _ox,int _oy);

+	void draw(float a,unsigned char* controllers,int xshift,int yshift,playlist &list,bool transparentBlack,int note,int mode,ofColor* controller_colours,bool controlColours,float scale,float fscale,float colShift,int fadeBG);

+        virtual ~viewport();

+	ofFbo rb1,rb2;

+	float r;

+    protected:

+    private:

+	int x, y,w,h,ox,oy;

+

+};

+

+#endif // VIEWPORT_H