diff scanpath.mm @ 3:d346ddc50f70

Vectorised a few things. Fiddled with new mesh creator... not solved much.

--- a/scanpath.mm	Thu Nov 22 17:58:34 2012 +0000
+++ b/scanpath.mm	Fri Dec 07 19:20:57 2012 +0000
@@ -10,30 +10,36 @@
 #include "scanpath.h"
 #include "testApp.h"
 
+ScanPath scanPath;
+
+// audio thread does not touch mesh lumps/springs
 //----------------------------------------------------------------
-ScanPath::ScanPath() : maxElements(2048) {
+ScanPath::ScanPath() : maxElements(10000) {
 	// construct an empty scanpath
 	// an ' element ' consists of 1 lump and one spring
 
     
 	numElements = 0; // numElements is a dynamic running count of elements when building - a bit crap
-    springPath = new Spring*[maxElements];
-    lumpPath = new Lump*[maxElements];
+ 
     
-    framesPerSample = ofGetFrameRate()/SAMPLE_RATE;
     frameInterpolator = 0.0;
     currentLength = 0.0;
     restLength = 1.0; // ?
 
     scanMode = DISPLACEMENT;
+    initWavetables();
+    framesPerSample = 60.0/SAMPLE_RATE;
+
+}
+void ScanPath::init(){
+    framesPerSample = ofGetFrameRate()/SAMPLE_RATE;
     
-    initWavetables();
-
 }
 //----------------------------------------------------------------
 ScanPath::~ScanPath(){
-	delete [] springPath;
-    delete [] lumpPath;
+    
+    //VECTORISE
+
     delete [] wavetableNew;
     delete [] wavetableOld;
     delete [] wavetableUpdate;
@@ -41,14 +47,17 @@
 }
 
 void ScanPath::clear(){
-    for(int i = 0; i<numElements; i++){
-        springPath[i]->removeFromScanPath();
-        lumpPath[i]->removeFromScanPath();
+    //VECTORISE
+    for(vector<Element>::iterator elitr = pathElements.begin(); elitr < pathElements.end(); elitr++){
+        (*elitr).eLump->removeFromScanPath();
+        (*elitr).eSpring->removeFromScanPath();
     }
+    pathElements.clear();
     numElements = 0;
-    // cant work?
+
 }
 int ScanPath::howManyElements(){
+    //return pathElements.size();
     return numElements;
 }
 //----------------------------------------------------------------
@@ -57,6 +66,8 @@
 	// if we're further away from current lump
 	
 	// check end points of connecting springs, pick closest
+    
+    // NOW IN MESH
 }
 void ScanPath::draw(){
     // draw the actual waveform in the corner
@@ -103,8 +114,10 @@
 double ScanPath::getTotalLength(){
     // for interesting modulations...
     currentLength = 0.0;
-    for(int i = 0; i < numElements; i++){
-        currentLength += springPath[i]->getLength();
+
+    for(vector<Element>::iterator elitr = pathElements.begin(); elitr < pathElements.end(); elitr++){
+
+        currentLength = (*elitr).eSpring->getLength();
     }
     return currentLength;
     
@@ -123,19 +136,23 @@
     
 }
 //----------------------------------------------------------------
-void ScanPath::addElement(Lump* aLump, Spring * aSpring){
+void ScanPath::addElement(Lump* const aLump, Spring * const aSpring){
     // insert ptr to the lump and spring into array
-    if(numElements >= maxElements){
-        cerr << "cannot add any more to scanpath - max elements: 2048\n";
+
+    
+    if(numElements + 1 >= maxElements){
+        cout << " max elements reached!\n";
         return;
     }
-    lumpPath[numElements] = aLump;
-    springPath[numElements] = aSpring;
+
+    pathElements.push_back(Element(aLump,aSpring));
     
+    // maybe do this in mesh?
     aLump->addToScanPath();
     aSpring->addToScanPath();
+    numElements++;
     
-    numElements++;
+
 }
 //----------------------------------------------------------------
 void ScanPath::updateWavetables(){
@@ -143,29 +160,48 @@
     double * temp;
 
     // TODO THRED MUTEX HERE!??
+    // this is called from graphics thread
+    // reset the interp between frames
     
+    /*
+    int i = 0;
+    while(audioAccessing){
+        i++;
+    }
+    cout << "buffers swapped while update!" << i << "times\n";
+    updateAccessing = true;
+     
+     */
     switch(scanMode){
         case DISPLACEMENT:
             // now fill with new values
             for(int i = 0; i < numElements; i++){
-
-                wavetableUpdate[i] = lumpPath[i]->scanRadialDisplacement()/1.5;
+                // double check
+                if(pathElements[i].eLump->isInScanPath){
+                    wavetableUpdate[i] = pathElements[i].eLump->scanRadialDisplacement()/1.5;
+                }
                 
             }
             break;
         case SPEED:
             for(int i = 0; i < numElements; i++){
-                wavetableUpdate[i] = lumpPath[i]->scanLumpSpeed();
+                if(pathElements[i].eLump->isInScanPath){
+                    wavetableUpdate[i] = pathElements[i].eLump->scanLumpSpeed();
+                }
             }
             break;
         case SPRING_FORCE:
             for(int i = 0; i < numElements; i++){
-                wavetableUpdate[i] = springPath[i]->getForceMag();
+                if(pathElements[i].eSpring->isInScanPath){
+                    wavetableUpdate[i] = pathElements[i].eSpring->getForceMag();
+                }
             }
             break;
         case YPOS:
             for(int i = 0; i < numElements; i++){
-                wavetableUpdate[i] = lumpPath[i]->scanYPos();
+                if(pathElements[i].eLump->isInScanPath){
+                    wavetableUpdate[i] = pathElements[i].eLump->scanYPos();
+                }
             }
             break;
         default:
@@ -174,17 +210,15 @@
           
     }
     
-    // END THREAD MUTEX
+    
+    
  
-    // reset the interp between frames
-    if(audioAccessing){
-        cout << "buffers swapped while update!\n";
-    }
-    updateAccessing = true;   
     temp = wavetableOld;
     wavetableOld = wavetableNew;
     wavetableNew = wavetableUpdate;
     wavetableUpdate = temp;
+    
+    // END THREAD MUTEX
     updateAccessing = false;
     
     frameInterpolator = 0.0;
@@ -192,7 +226,11 @@
     
 }
 //----------------------------------------------------------------
+//----------------------------------------------------------------
+// AUDIO THREAD STUFF
+//----------------------------------------------------------------
 // get next sample
+
 double ScanPath::getNextSample(double aPhasor){
 	// move along path, interpolating between points
     // move between frames too
@@ -207,12 +245,17 @@
 
     double frac = alongPath - double(n0);
     
+    // TODO THRED MUTEX HERE!??
+    // this is called from audio thread
+    /*
+    int i = 0;
+    while(updateAccessing){
+        i++;
+    }
     audioAccessing = true;
-    if (updateAccessing){
-        cout << "update is accessing while audio is\n";
-    }
-    
-    // TODO THRED MUTEX HERE!??
+    cout << "update is accessing while audio is" << i << "times\n";
+     
+     */
     
     double oldsample = (1 - frac) * wavetableOld[n0] + frac * wavetableOld[n1];