annotate PDSynthWrapper.h @ 3:c50de2d84732

used already written func

//
//  pdSynthWrapper.h
//  tweakathlon
//
//  Created by Robert Tubb on 14/01/2014.
//
//

#pragma once

#include "AppCore.h"
#include "eventLogger.h"
#include "ofxPd.h"
#include <string>
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "SynthParam.h"
#include "presetManager.h"

//---------------------------------------------------------------------
//---------------------------------------------------------------------
//---------------------------------------------------------------------

class PDSynthWrapper {
public:
    void init(AppCore* aCore, string sp){
        core = aCore;
        
        synthPrefix = sp;
        // init all the params, refer to synth in pd patch
        timbreParams.push_back(SynthParam(64,aCore,"Pitch",sp));
        timbreParams.push_back(SynthParam(64,aCore,"Pulse",sp));
        timbreParams.push_back(SynthParam(64,aCore,"Attack",sp));
        timbreParams.push_back(SynthParam(64,aCore,"Decay",sp));
        timbreParams.push_back(SynthParam(64,aCore,"FiltTyp",sp));
        timbreParams.push_back(SynthParam(64,aCore,"FiltFrq",sp));
        
        timbreParams.push_back(SynthParam(64,aCore,"SPAM",sp));
        timbreParams.push_back(SynthParam(64,aCore,"FILTH",sp));
        //timbreParams.push_back(SynthParam(64,aCore,"reson",sp));
        
        if (timbreParams.size() != TOTAL_NUM_PARAMS){
            cout << "ERROR ERROR: WRONG NUM OF timbreParams or TOTAL_NUM_PARAMS" << endl;
        }
        cout << "initialised synth: " << sp << " with " << timbreParams.size() << " params" << endl;
    };
    void sendAllParams(){
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            psp->sendToPD();
        }
    }
    void sendVolume(int value){
        List toPD;
        toPD.addSymbol(synthPrefix);
        toPD.addSymbol("Volume");
        toPD.addFloat(value); // rounding here??
        
        core->pd.sendList("fromOF", toPD);
    }
    void setNoteLength(int lms){
        List toPD;
        toPD.addSymbol(synthPrefix);
        toPD.addSymbol("noteLength");
        toPD.addFloat(lms); // volume here, just in case??
        
        core->pd.sendList("fromOF", toPD);
    }
    const int getParamValueForID(int pid){
        int v = 0;
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            if (psp->getID() == pid){
                v = psp->getValue();
                return v;
            }
            
        }
        cout << "ERROR ERROR getParamValueForID not found" << endl;
        return -1;
    }
    const int getMappingIDForName(string name) const{
        
        int rID = -1;
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            if (psp->getName() == name){
                rID = psp->getID();
                return rID;
            }
            
        }
        cout << "ERROR ERROR getMappingIDForName not found" << endl;
        return -1;
    };
    const string getNameForMappingID(int pid) const{
        
        string rname = "no name";
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            if (psp->getID() == pid){
                rname = psp->getName();
                return rname;
            }
            
        }
        cout << "ERROR ERROR getNameForMappingID not found" << endl;
        return "error";
    };
    vector<int> getMappingIDForIndices(vector<int> idx){
        vector<int> result;
        
        for(int i = 0 ; i < idx.size(); i++){
            if (idx[i] < timbreParams.size()){
                int mapid = timbreParams[idx[i]].getID();
                
                result.push_back(mapid);
                //cout << " Map id for param no: " << idx[i] << " is  " << *(result.end()-1);
            }else{
                cout << "ERROR ERROR: index bigger than num timbre params" << endl;
                
            }
        }
        return result;
    }
    
    void paramChangeCallback(int mappingID, int value){

        // look for id in params
        std::vector<SynthParam>::iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            if ( psp->getID() == mappingID){
                psp->setValue(value);
                return;
            }
        }
        cout << "ERROR ERROR: paramChangeCallback mappingID not found" << endl;
    };
    
    void trigger(){
        // play the noise
        List toPD;
        toPD.addSymbol(synthPrefix);
        toPD.addSymbol("playSound");
        toPD.addFloat(1.0); // volume here, just in case??
        
        core->pd.sendList("fromOF", toPD);

    };
    
    void randomiseParams(){
        
        cout << " randomising" << endl;
        std::vector<SynthParam>::iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){

            int value = ofRandom(0,127);
            psp->setValue(value);

        }
        
    };

    void setSameAsOtherSynth(const PDSynthWrapper* otherSynth){
        // loop thru all params and set them to other synth
        std::vector<SynthParam>::iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            psp->setValue(otherSynth->getParamValueFromName(psp->getName()));
    
        }
    };
    
    vector<int> randomiseParamSubset(int howMany){
        vector<int> randomisedIDs;
        for (int i=0;i<howMany;i++){
            
            int value = ofRandom(0,127);
            timbreParams[i].setValue(value);
            randomisedIDs.push_back(i);
            
        }
        return randomisedIDs;
        
    };
    
    const int getParamValueFromName(string name) const{
        
        int value = -1;
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            if (psp->getName() == name){
                value = psp->getValue();
                return value;
            }
            
        }
        cout << "ERROR ERROR: getParamValueFromName name not found" << endl;
        return -1;
    };
    
    const int getNumParams(){
        return timbreParams.size();
    };
    
    void setAllParams(vector<int> params){
        if(params.size() != timbreParams.size()){
            cout << "Error not right number of params in set in synth" << endl;
            return;
        }
        std::vector<SynthParam>::iterator psp;
        int i=0;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            psp->setValue(params[i]);
            i++;
        }
        

    }
    vector<int> getAllParamValues(){
        vector<int> pl;
        std::vector<SynthParam>::const_iterator psp;
        for(psp = timbreParams.begin(); psp < timbreParams.end(); psp++){
            pl.push_back(psp->getValue());
        }
        return pl;
    }
    
    void storeParamsAsPreset(string name){
        presetManager.savePreset(name, getAllParamValues());
    }
private:
    string synthPrefix;
    AppCore* core;
    PresetManager presetManager; // TODO not here
    vector<SynthParam> timbreParams; // array of everything in synth
  
};

//---------------------------------------------------------------------
//---------------------------------------------------------------------