oscThread

#include "ofApp.h"

//--------------------------------------------------------------
void ofApp::setup(){
    ofSetVerticalSync(true);
    numMesh = 3;

    /*for(int i=0;i<numMesh;i++){
        mesh.addVertex(ofPoint(ofRandom(ofGetWidth()),ofRandom(ofGetHeight()),ofRandom(600)));
        mesh.addColor(ofColor(ofRandom(255)));

        offsets.push_back(ofVec3f(ofRandom(0,10000),ofRandom(0,10000),ofRandom(0,10000)));
        mesh.setupIndicesAuto();
    }*/
    mesh.addVertex(ofVec3f(-150,0));
    mesh.addVertex(ofVec3f(150,0));
    mesh.addVertex(ofVec3f(200,50));
    //mesh.addVertex(ofVec3f(50,0));
    mesh.addColor(ofColor(255));

    mesh.setMode(OF_PRIMITIVE_POINTS);

    //GUI
    gui.setup();
    gui.add(res.set("Number of Vertices",100,10,200));
    gui.add(amp.set("Amplitude",10,1,100));
    gui.add(f.set("Frequency",10,1,100));
    gui.add(speed.set("Speed",5,1,50));

    glEnable(GL_POINT_SMOOTH);
    glPointSize(3);
}

//--------------------------------------------------------------
void ofApp::update(){
    if(braid.size()>0){
        for(int i=0;i<braid.size();i++){
            for(int j=0;j<braid[i].size();j++){
                braid[i][j].amp = amp;
                braid[i][j].speed = speed;
                braid[i][j].f = f;
                braid[i][j].update();
            }
        }
    }

    //Point Jitter
    /*
    for(int i=0;i<numMesh; i++){
        ofVec3f vert = mesh.getVertex(i);

        float time = ofGetElapsedTimef();
        float timeScale = 5.0;
        float displacementScale = 0.75;
        ofVec3f timeOffsets = offsets[i];

        vert.x += (ofSignedNoise(time*timeScale+timeOffsets.x)) * displacementScale;
        vert.y += (ofSignedNoise(time*timeScale+timeOffsets.y)) * displacementScale;
        vert.z += (ofSignedNoise(time*timeScale+timeOffsets.z)) * displacementScale;

        mesh.setVertex(i,vert);
    }
     */
}

//--------------------------------------------------------------
void ofApp::draw(){
    //ofEnableDepthTest();
    //ofBackgroundGradient(ofColor(50), ofColor(0));

    cam.begin();
    mesh.draw();
    if(braid.size()>0){
        for(int i=0;i<braid.size();i++){
            for(int j=0;j<braid[i].size();j++){
                braid[i][j].draw();
            }
        }
    }
    cam.end();

    ofDrawBitmapString("Number of Braids: " + ofToString(braid.size()),10,10);
    gui.draw();
}

//--------------------------------------------------------------
void ofApp::keyPressed(int key){
    if(key=='f'){
        vector<oscThread> tempBraid;    //Inner vector
        ofVec2f tempOrigin;             //Origin/dest vector
        tempOrigin.set(ofRandom(numMesh),ofRandom(numMesh));

        if(tempOrigin.x == tempOrigin.y){       //Check unique
            tempOrigin.y = ofRandom(numMesh);
        }

        for(int i=0;i<1;i++){
            tempBraid.push_back(oscThread(tempOrigin,mesh));
            tempBraid.back().res = res;
            tempBraid.back().setup();   //Setup new threads
        }

        braid.push_back(tempBraid);     //Finally insert tempBraid into outer vector
    }
}

//--------------------------------------------------------------
void ofApp::keyReleased(int key){

}

//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){

}

//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){

}

//ofApp.h

#pragma once

#include "ofMain.h"
#include "oscThread.h"
#include "ofxGui.h"

class ofApp : public ofBaseApp{

public:
    void setup();
    void update();
    void draw();

    void keyPressed(int key);
    void keyReleased(int key);
    void dragEvent(ofDragInfo dragInfo);
    void gotMessage(ofMessage msg);

    int numMesh;

    ofEasyCam cam;
    ofMesh mesh;
    vector< vector<oscThread> > braid;
    vector<ofVec3f> offsets;

    ofParameter<float> amp;
    ofParameter<float> f;
    ofParameter<int> res;
    ofParameter<int> speed;

    ofxPanel gui;
};

//oscThread.cpp

#include "oscThread.h"

oscThread::oscThread(ofVec2f origin, ofMesh mesh)
{
    originP = mesh.getVertex(origin.x);
    destP = mesh.getVertex(origin.y);//x and y should be checked to be unique, or
        //else they can both point to the same index

    color = ofColor(ofRandom(200));
    res   = 150;                            //Resolution (also relates to actual freq?)
    speed = 5;                              //Speed (lower=faster)
    amp   = 10;                             //Amplitude
    f     = 3;                             //Frequency

    numVerts  = 0;
}

void oscThread::setup()
{
    numVerts = this->getMesh().getNumVertices();
    float time = ofGetElapsedTimef()/speed;

    this->getMesh().addVertex(originP);
    this->getMesh().addColor(color);

    for (float x=0;x<res;x++){
        float delta = x/res;
        float p = x;
        float oscillation = amp * sin((2 * pi * f * time + p)/20);
        ofVec3f signal = originP.getInterpolated(destP, delta);
        offsetZ.push_back(signal.z);

        ofPushMatrix();
            signal.z = oscillation;
        ofPopMatrix();

        this->getMesh().addVertex(signal);
        this->getMesh().addColor(color);

        numVerts++;
    }

    this->getMesh().addVertex(destP);
    this->getMesh().addColor(color);

    this->getMesh().setMode(OF_PRIMITIVE_LINE_STRIP);

    //VBO TESTING
    this->setUseVbo(TRUE);

    glLineWidth(2);
}

void oscThread::draw()
{
    transformGL();
        this->getMesh().draw();
    restoreTransformGL();
}

void oscThread::update()
{
    float time = ofGetElapsedTimef()/speed;

    for (int x=0;x<res;x++){
        ofVec3f oscTemp = this->getMesh().getVertex(x);
        float p = x;
        float oscillation = amp * sin(2 * pi * f * time + p);

        ofPushMatrix();
            oscTemp.rotate(x/f,ofVec3f(1,0,0));
        ofPopMatrix();

        //oscTemp.z = oscTemp.z + offsetZ[x];
        this->getMesh().setVertex(x,oscTemp);
    }

    //this->tilt(0.01); // Constant rotation
}

//oscThread.h

#ifndef _OSC_THREAD
#define _OSC_THREAD

#include "ofMain.h"

class oscThread : of3dPrimitive {

public:
    void setup();
    void draw();
    void update();

    ofVec3f originP;
    ofVec3f destP;
    vector<float> offsetZ;

    ofColor color;

    int   res;    //Resolution
    int   speed;  //Speed (lower=faster)
    float amp;    //Amplitude
    float f;      //Frequency

    int numVerts;

    oscThread(ofVec2f origin, ofMesh mesh);
};

#endif