zeffii / csound_patches Goto Github PK

things i need

• drumkit
  • kicks
  • hats
  • shaker
  • tom
  • cymbal
• samplers
  • adsr
  • advanced envelope
• synths
  • dumsynth [ kick, hat, snare, tom, rim, clave, ride, crash ]
  • padsynth
  • fm synth
  • chaos
  • grain synth
• fx
  • vibrato
  • phase / flange
  • delay (tap, filter)
  • reverb
  • filter (hp, lp)
  • distortion (clamp, fold, overdrive, redrive)
    - redrive: max out amp, rescale down, and reamp proportionally to original amp.
  • band spread
  • vocoder

the good thing about C++ is that almost anything you can think of has been asked before.

#include <iostream>
#include <sstream>
#include <string>
#include <math.h>
#include "Formulas.hpp"

using namespace std;

string helper_converter(int num){
    stringstream stream;
    stream << std::hex << num;
    return stream.str();
};

string uppercase(string str){
    int str_len = str.length();
    for(int i = 0; i < str_len; i++)
        str[i] = toupper(str[i]);
    return str;
};


// the constructor
Formulas::Formulas(string newname)
{
    cout << newname << endl;
}

// the method
void Formulas::printMore(){
    cout << "thats the way we like it\n";
}

void Formulas::interpolate_hex(int elements, string h_start, string h_end){
    /*
    - first convert h_start amd h_end to integers
    - generate the range between these integers (given range of n elements)
    - print the hex range of these newly generated elements.
    */
    unsigned int x_1, x_2;
    unsigned int x_transition[elements];
    stringstream ss_1, ss_2;

    ss_1 << std::hex << h_start;
    ss_2 << std::hex << h_end;
    ss_1 >> x_1;
    ss_2 >> x_2;

    cout << h_start << " h_start: " << x_1 << endl;
    cout << h_end   << " h_end: "   << x_2 << endl;

    float stepsize = ((float) x_2 - x_1) / elements;

    for (int i = 0 ; i <= elements; i++){
        float intermediate_value = x_1 + (stepsize * i);
        int temp_int = round(intermediate_value);
        string hex_value = helper_converter(temp_int);
        hex_value = uppercase(hex_value);
        
        cout << intermediate_value << " and -> " << temp_int << " becomes " << hex_value << endl;
    }

}

03 Oktober 2020
I've been wanting to write my own tracker software for about 20 years, maybe 25. Being introduced to ChucK opened my eyes to audio programming and demistified the kinds of thinking required. Over that period I learned openGL and python (+ other languages ), but found python expressive , supercollider not so much and puredata was a bit mouse heavy. I hate using the mouse, this originates from my ImpulseTracker days.

i'm 300+ pages into the Floss csound manual, things are gradually starting to make sense, it seems exactly sufficient for my needs - but i won't know until a few clips of music emerge.

1. The idea is to first make a bunch of synths and presets and learn about sample loading / manipulated playing.
2. then see if it can be sequenced non-realtime in a way that makes sense to me (preferably in realtime...eventually)
3. write some kind of tracker UI (language may be python first...) , which lets me have a track connected to a codewindow inside which i can write opcodes / isntruments
4. abstract the synth writing with timedomain graphs to show the envlopes
5. abstract the synth as a graph / node system. (but this is definitely not essential... maybe nice later)