comparison scanpath.mm @ 3:d346ddc50f70

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

  */
 #include <vector>
 #include "scanpath.h"
 #include "testApp.h"
 
-//----------------------------------------------------------------
-ScanPath::ScanPath() : maxElements(2048) {
+ScanPath scanPath;
+
+// audio thread does not touch mesh lumps/springs
+//----------------------------------------------------------------
+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;
+    
 }
 //----------------------------------------------------------------
 ScanPath::~ScanPath(){
-	delete [] springPath;
-    delete [] lumpPath;
+    
+    //VECTORISE
+
     delete [] wavetableNew;
     delete [] wavetableOld;
     delete [] wavetableUpdate;
     cout << "destructed scanpath\n"; 
 }
 
 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;
 }
 //----------------------------------------------------------------
 void ScanPath::inscribe(double ax, double ay){
 	// look at coordinates, add the closest lump and it's connecting string 
 	// 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
 
     int width = 768;

 //----------------------------------------------------------------
 // add lump
 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;
     
 }
 //----------------------------------------------------------------

         wavetableUpdate[i] = 0.0;
     }
     
 }
 //----------------------------------------------------------------
-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++;
+    
+
 }
 //----------------------------------------------------------------
 void ScanPath::updateWavetables(){
     // swap old , new
     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:
             break;
             
           
     }
     
-    // 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;
     framesPerSample = 2.0*ofGetFrameRate()/SAMPLE_RATE; // attempt to get a reasonable est. of how fast to interp
     
 }
 //----------------------------------------------------------------
+//----------------------------------------------------------------
+// AUDIO THREAD STUFF
+//----------------------------------------------------------------
 // get next sample
+
 double ScanPath::getNextSample(double aPhasor){
 	// move along path, interpolating between points
     // move between frames too
     double alongPath = aPhasor*double(numElements);
     

         n1 = 0;
     }
 
     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];
     
     double newsample = (1 - frac) * wavetableNew[n0] + frac * wavetableNew[n1];