Subversion Repositories DIN Is Noise

/*

* main.cc

* DIN Is Noise is copyright (c) 2006-2025 Jagannathan Sampath

* DIN Is Noise is released under GNU Public License 2.0

* For more information, please visit https://dinisnoise.org/

*/

#include <SDL/SDL.h>

#include <string>

#include <map>

#include <vector>

#include <iostream>

#include <fstream>

#include <list>

#include <algorithm>

#include <tcl.h>

#include "dingl.h"

#include "main.h"

#include "box.h"

#include "utils.h"

#include "font.h"

#include "ui_list.h"

#include "console.h"

#include "input.h"

#include "viewwin.h"

#include "curve.h"

#include "multi_curve.h"

#include "solver.h"

#include "chrono.h"

#include "curve_editor.h"

#include "font_editor.h"

#include "din.h"

#include "curve_library.h"

#include "console_iterator.h"

#include "delay.h"

#include "random.h"

#include "globals.h"

#include "command.h"

#include "scalelist.h"

#include "morse_code.h"

#include "sine_mixer.h"

#include "tcl_interp.h"

#include "compressor.h"

#include "oscilloscope.h"

#include "keyboard_keyboard.h"

#include "authors_note.h"

#include "midi_in.h"

#include "menu.h"

#include "curve_picker.h"

#include "fractaliser.h"

#include "rose_milker.h"

#include "circler.h"

#include "spiraler.h"

#include "starrer.h"

#include "lissajous.h"

#include "superformula.h"

#include "warper.h"

#include "recorder.h"

#include "mondrian.h"

#include "instrument.h"

#include "countries.h"

#include "morpher.h"

#include "number.h"

#include "binaural_drones.h"

#include "fft.h"

#include "capturer.h"

#include "noiser.h"

#include "defvelaccel.h"

#include "just.h"

using namespace std;

#if defined __GPL20__

  string home = getenv ("HOME");

  string user_data_dir (home + "/.din/"); // contains defaults, user savings and prefs

  string country_data_dir (user_data_dir + "country/"); // contains country data used by countries plugin (see countries.cc)

#elif defined (__MACOSX_CORE__) || defined (__LINUX_BIN__)

  string user_data_dir = "user/";

  string country_data_dir = "user/country/";

#elif __WINDOWS_DS__

  string user_data_dir = "user\\";

  string country_data_dir = "user\\country\\";

#endif

ofstream dlog ("log", ios::out); // DIN Is Noise log

extern const float GOLDEN_RATIO = 1.618033;

extern const float PI = 3.1415961;

extern const float TWO_PI = 2 * PI;

extern const float PI_BY_180 = PI / 180.;

extern const char spc = ' ';

char tokenizer::delim = spc;

// for attack, decay and deltas [see keyboard-keyboard.cc, mondrian.cc, triggered_note.cc]

extern const float MIN_TIME = 0.01f; // seconds

tcl_interp interpreter; // integrated TCL interpreter

int quit = DONT;

struct startup_shutdown {

  startup_shutdown () {

    dlog << "!!! started DIN Is Noise @ "  << interpreter ("clock format [clock seconds]").result << " !!!" << endl;

    time_t t0 = time(0);

    seed_rand_gen (t0);

    dlog << "+++ initialised random number generator @ seed = " << t0 << " +++" << endl;

  }

  ~startup_shutdown () {

    SDL_Quit ();

    dlog << "!!! cleaned up SDL !!!" << endl;

    dlog << "*** [Mondrian] box count = " << rect::ref << " ***" << endl;

    dlog << "*** [Mondrian] ball count = " << ball::ref << " ***" << endl;

    dlog << "*** [Mondrian] slit count = " << slit::ref << " ***" << endl;

    dlog << "*** [Microtonal-Keyboard] drone count = " << drone::ref << " ***" << endl;

    dlog << "\\o/ DIN Is Noise was up for " << interpreter ("uptime 0").result << " \\o/" << endl;

    dlog << "DIN Is Noise shutdown @ " << interpreter ("clock format [clock seconds]").result << endl;

  }

} SS ;

help curve_editor::helptext ("curve_editor.hlp");

// DIN clocks

double TIME_NOW = 0; // in seconds on the audio clock stored in variable timenow on TCL interpreter

audio_clock clk; // audio clock

ui_clock ui_clk; // UI clock

// keyboard and mouse state

keyboard keybd;

int mousex = 0, mousey = 0, mouseyy = 0; // absolute mouse x, y & main viewport y

int lmb = 0, mmb = 0, rmb = 0; // left & right mouse buttons

int wheel = 0; // mouse wheel

int wheely = -60; // for moving menu, settings widgets

int SHIFT = 0; // shift button

int CTRL = 0; // ctrl button

int ALT = 0; // alt button

is_lmb_t is_lmb; // for acquiring lmb

// UI

int UI_OFF = 0;

int widget::HOVER = 0; // mouse hovering on any widget?

widget* widget::focus = 0; // widget that has focus

widget* widget::next_focus = 0; // widget waiting to have focus

// see spinner.h, spinner2.h

int SPACING = 6;

int VAR_MIN = -100, VAR_MAX = 100; // for variance @ spinner.h

int VAR_MIN2 = 0, VAR_MAX2 = 100; // for variance @ spinner2.h

string VARSTR, VARSTR2;

// widget defaults

// loaded from globals file (see globals.cc)

float widget::R, widget::G, widget::B; // default widget color

int widget::bb [16] = {0}; // widget bounding box

color checkbutton::on_color, checkbutton::off_color; // checkbutton on/off colors

const char* field::fmts [] = {"%0.3f", "%0.4f", "%0.6f", "%f"}; // precision formats for field

int FPS = 0; // requested frames per second

double TIME_PER_FRAME; // in seconds, calc @ command.cc

double LAST_FRAME_TIME = 0.0;

double FPSNOW = 0.0;

int IPS; // requested keyboard/mouse inputs per second

double TIME_PER_INPUT; // in seconds

double LAST_INPUT_TIME = 0.0;

double IPSNOW = 0.0;

int basic_editor::hide_cursor = 0; // to hide cursor when mouse is on a ui control

float* basic_editor::gl_pts = 0;

float* basic_editor::gl_clr = 0;

int basic_editor::n_pts = 0;

int basic_editor::ref = 0;

const char* basic_editor::drawt::snapss[2] = {"Not drawing snapping guides", "Drawing snapping guides"};

const char* basic_editor::drawt::guides[2] = {"Not drawing cursor guide", "Drawing cursor guide"};

int plugin::change_curve_name = 1; // when applying plugin?

int capturer_t::ref = 0; // see capturer.h

int point_modulator::ref = 0; // see point_modulator.h

list<crvpt> LIST_OF_POINTS; // list of points (see curve.h/cc)

// binaurality

//

int DIN_IS_BINAURAL = 0; // default no (for now :)

int JUSTIFICATION = just::RANDOM;

float SEPARATION = 4.0f;

// see drone.h/cc

int drone::UID = 0; // unique id for drones

int drone::ref = 0; // for ref counting drones

map<drone*, bool> drone::proc_conn; // drone connections

float drone::STIFFNESS = 1.0f; // stiffness of inter-drone connections

double drone::LIFETIME = 3; // for launched drones (seconds)

int drone::HANDLESIZE = 3; // default drone handle size

double drone::INSERTTIME = 3; // for launched drones to get into orbit (seconds)

double drone::gabt = 1.0f; // for mute/unmute drones

float drone::MASTERVOLUME = 0.0f; // for all drones

point<float> mod_params::horizontal (1.0f,0.0f), mod_params::vertical (0.0f,1.0f); // drone modulation directions

int drone::IS = drone::DRONE;

drone::wandt drone::wand (5.0); // for wandded drones

anglet drone::chuckt::apt; // angle per turn (degrees) for chuck rotation

int drone::chuckt::outline = 1; // draw chuck outlines?

int drone::chuckt::autoresettrails = 1; // when chuck params changed?

int drone::ARE = drone::IMMORTAL; // type of drone

int drone::anchored = 0;

float drone::arrowt::U = 0.25, drone::arrowt::V = 0.25, drone::arrowt::K = 1.0f, drone::arrowt::CAP = 1;

defvelaccel drone::v0 (" Velocity"), drone::a0 (" Acceleration");

const char* menu::defvelaccelui::autopauset::tars[] = {" Target is Auto rotate", " Target is Auto flip"};

multi_curve drone::modvt::crv ("modv.crv");

float drone::anchoropacity = 0.5;

// for drone <> noise conversion

drone::drone2noise drone::dnl;

drone::noise2drone drone::ndl;

drone::fin* drone::fins[3] = {0, &drone::dnl, &drone::ndl};

double drone::posafxvelt::minmag = 3.0f;

// for trails on drones and mondrian

float* trail_t::tpts = 0;

int trail_t::n_tpts = 0;

// drone mesh, see mesh.h/cc

int* mesh::gl_pts = 0;

float* mesh::clr = 0;

int mesh::n_glpts = 0;

int proximity_orderer::ROW = 0, proximity_orderer::COL = 0;

double fader::TIME; // loaded from din_info

// see curve_mixer.h/cc

float curve_mixer::TIME = 1.0f; // curve (waveform/envelope) mixing time in seconds

int curve_mixer::SAMPLES = 1024; // curve mixing time in samples, change one, changes the other

double curve_mixer::ELAPSEDT = 0.0;

// for sprintf

const int BUFFER_SIZE = 1 << 15;

char BUFFER [BUFFER_SIZE] = {0};

// music constants

//

int NUM_NOTES = 13;

// notations

int NOTATION = WESTERN;

const char* notation_types [] = {"numeric", "western", "indian"};

const char* WESTERN_SHARP [] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B", "C"};

const char* WESTERN_FLAT [] = {"C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B", "C"};

const char* INDIAN_SWAR [] = {"s", "r", "R", "g", "G", "m", "M", "P", "d", "D", "n", "N", "S"};

//const char* SOLFEGE [] = {"Do", "re", "Re", "mi", "Mi", "fa", "Fa", "So", "la", "La", "ti", "Ti", "Do"};

// for the octave of Middle-C; from wikipedia - piano key frequencies page.

float WIKIPEDIA_KEY_FREQUENCIES [] = {

  261.626f, 277.183f, 293.665f, 311.127f, 329.628f, 349.228f, 369.994f, 391.995f, 415.305f, 440.0f, 466.164f, 493.883f, 523.251f

};

string NEAREST_NOTE; // note nearest to key of DIN

float NEAREST_NOTE_DISTANCE; // distance in Hz of the nearest note from the key of DIN

float NEAREST_NOTE_FREQUENCY; // frequency in Hz of the nearest note to the key of DIN

int SAMPLE_RATE; // sample rate of DIN

float SAMPLE_DURATION; // duration of an audio sample in seconds

string SCALE; // current scale

string TUNING; // current tuning

int NUM_INTERVALS; // number of intervals in tuning

string INTERVALS_FILE; // file name that contains interval info

map <string, float> INTERVALS; // interval name -> value

map <string, string> INT2IND;

vector<string> INTERVAL_NAMES; // sequential interval names (eg., 1 2b 2 3b 3 ... 7b 7 8)

vector<float> INTERVAL_VALUES; // sequential interval values (eg., value of 1 2b 3 3b ... 7b 7 8)

map <string, int> NOTE_POS; // interval name -> note number (eg., 1 => 0, 2b => 1, 3 => 2, etc)

scale_info all_notes; // used by change left/right note on range to move to any note

//

// microtonal keyboard

//

const char* s_drones = " drones";

int LEFT = 0, BOTTOM, TOP;

int WIDTH, HEIGHT;

int TRAILSIZE = 0; // default drone trail size (== number of trail points), mondrian ball trail size

int NUM_OCTAVES = 3; // number of octaves

// random bpm init see range::init_mod()

// limits loaded from globals file, see globals.cc

rnd<int> RAN_MOD_BPM;

const char* din_info::cnn_opts [] = {" to scale note", " to any note"};

const char* din_info::cnno [] = {"Octave", "Note"};

// see curve_samples in curve_editor.h

float curve_samples::dm = 0.0f;

float curve_samples::nsec = 1.0f;

// screens - 1 is instrument; 2 - 8 are editors

//

const Uint8 ui_list::key [] = {SDLK_2, SDLK_3, SDLK_4, SDLK_5, SDLK_6, SDLK_7, SDLK_8}; // keys 2 - 8

ui* ui_list::ed [] = {0};

ui* ui::over = 0;

// solver xhandlers; see solver.cc

atmin _atmin;

atmax _atmax;

tomin _tomin;

tomax _tomax;

loopmin _loopmin;

loopmax _loopmax;

pongmin _pongmin;

pongmax _pongmax;

// see multi_curve.cc

multi_curve curve_editor::copy;

multi_curve mix;

color curve_editor::vtxlbl; // vertex label color

int hit_t::name_only = 0;

// see sine_mixer.cc

int sine_mixer::NUM_SINE_SAMPLES = 100;

const int sine_mixer::MIN_SINE_SAMPLES = 4;

// program info

string APP_NAME;

string VERSION_NUMBER;

//

// display

//

int FULL_SCREEN = 0; // full screen?

const int SCREEN_DEPTH = 24; // fixed color depth

// see viewwin.cc

viewport view; // display - using OpenGL

int viewport::handle_radius;

float viewport::handle_factor;

int window::PAN_RATE = 100, window::ZOOM_RATE = 100;

double window::PAN_REPEAT = 1.0 / PAN_RATE, window::ZOOM_REPEAT = 1.0 / ZOOM_RATE;

float window::PAN_AMOUNT = 0.1f, window::ZOOM_AMOUNT = 0.1f;

load_globals lg;

// 0 init correct for oscilloscope; see oscilloscope.cc

float oscilloscope::sample_t::lmin = 0, oscilloscope::sample_t::lmax = 0;

float oscilloscope::sample_t::rmin = 0, oscilloscope::sample_t::rmax = 0;

oscilloscope scope ("scope.osc");

// custom vector font

#ifdef __SVG_FNT__

  font fnt ("laser.fnt");

#elif __PLOTTER_FNT__

  font fnt ("plotter.fnt");

#else

  font fnt ("jag.fnt");

#endif

int line_height; // of text

// console

//

console cons;

// possible text colors

const float cc = 0.75f;

const color console::yellow (1, 1, cc);

const color console::green (cc, 1, cc);

const color console::red (1, cc, cc);

const color console::cyan (cc, 1, 1);

const color console::white (1, 1, 1);

const char* console::precision = "%.3f";

void set_window_caption () {

  make_app_name ();

  SDL_WM_SetCaption (APP_NAME.c_str(), APP_NAME.c_str());

}

string CHARSET [] = { // list of input chars

  // US layout

  "abcdefghijklmnopqrstuvwxyz0123456789 .=-/;\\,[]'`", // normal

  "ABCDEFGHIJKLMNOPQRSTUVWXYZ)!@#$%^&*( >+_?:|<{}\"~", // shift

};

const int CHARSET_LENGTH = CHARSET[0].length ();

char get_typed_char () { // get char typed on an input area

  const string& norm = CHARSET[0];

  const string& shift = CHARSET[1];

  for (int i = 0; i < CHARSET_LENGTH; ++i) {

    if (keypressedd (norm[i])) {

      if (SHIFT || keydown (SDLK_CAPSLOCK))

        return shift[i];

      else

        return norm[i];

    }

  }

  return 0;

}

// audio output

//

audio_out aout;

// list of scales

scalelist scalelst;

//

// L and R delays

//

delay left_delay (1000, "feedback-l.crv", "volume-l.crv"), right_delay (1000, "feedback-r.crv", "volume-r.crv");

curve_editor delayed ("delay.ed");

font_editor fed (fnt, "font.ed", "font.hlp");

multi_curve dummy ("dummy.crv");

// vars in Tcl interpreter

//

// midi bpm from external midi clock

double MIDI_BPM = 0;

// tap bpm from computer keyboard

double TAP_BPM = 0;

// microtonal-keyboard height (0 to 1)

float VOLUME = 0;

fft fft0; // FFT of waveform in waveform editors

cmdlist cmdlst; // list of din commands

// 1 oscillator / waveform for lead

//

float VOICE_VOLUME = 0.2f;

//

// curve libraries

//

curve_library wav_lib ("waveforms.lib"); // waveforms

curve_library sin_lib ("sin.lib"); // custom sine curves 

curve_library cos_lib ("cos.lib"); // custom cosine curves 

curve_library attack_lib ("attack.lib", 1); // attack curves [1 = has_sustain]

curve_library decay_lib ("decay.lib"); // decay curves

// compressor

compressor coml ("coml.crv"), comr ("comr.crv");

curve_editor comed ("compressor.ed");

// octave shift

//

beat2value octave_shift ("os", "octave-shift.crv");

curve_editor octed ("octave-shift.ed");

curve_library octlib ("octave-shift-patterns.lib");

beat2value_listener octlis;

// drone modulation

//

multi_curve drone_mod_am_crv ("drone-mod-am.crv");

multi_curve drone_mod_fm_crv ("drone-mod-fm.crv");

curve_editor drone_mod_ed ("drone-modulation.ed");

drone_mod_lis dmlis;

// range modulation

multi_curve ran_mod_width_crv ("range-mod-width.crv");

multi_curve ran_mod_height_crv ("range-mod-height.crv");

curve_editor ran_mod_ed ("range-modulation.ed");

// point modulation

curve_editor pomo_ed ("point-modulation.ed");

multi_curve pomo_x_crv ("pomo-x.crv");

multi_curve pomo_y_crv ("pomo-y.crv");

pomo_lis pol;

// range width/height set

multi_curve ran_width_crv ("range-width.crv"), ran_height_crv ("range-height.crv");

solver sol_ran_width (&ran_width_crv), sol_ran_height (&ran_height_crv);

curve_editor ran_wh_ed ("range-width-height.ed");

range_wh_lis rwhl;

// pitch / volume distribution

multi_curve pitch_crv ("pitch.crv"), vol_crv ("vol.crv");

curve_editor pitch_vol_ed ("pitch-vol.ed");

solver warp_pitch (&pitch_crv), warp_vol (&vol_crv);

multi_curve* warcrv [] = {&pitch_crv, &vol_crv};

solver* warsol_pv [] = {&warp_pitch, &warp_vol};

pitch_vol_lis pvl;

// noise interpolation

multi_curve noiser::interp ("noiser.crv");

curve_editor noiser::ed ("noiser.ed");

noise_interp_lis noiser::lis;

// drone pendulum depth & bpm

multi_curve dp_depth ("dp_depth.crv"), dp_bpm ("dp_bpm.crv");

curve_editor drone_pend_ed ("drone-pend.ed");

solver warp_depth (&dp_depth), warp_bpm (&dp_bpm);

solver* warsol_dp [] = {&warp_depth, &warp_bpm};

multi_curve* dp_crv [] = {&dp_depth, &dp_bpm};

drone_pend_ed_lis dpel;

recorder recorder0; // for recording sounds made in DIN

// microtonal-keyboard see din.cc/.h

//

const string din::PSD = "Please select some drones!";

const string din::A2D = "Please select at least 2 drones.";

const char* ol_fixed_lbls [] = {" with left fixed", " with center fixed", " with right fixed"};

const char* voice_is_lbls [] = {"Noise", "Voice"};

din din0 (cmdlst);

int BEATER = 0; // beater editor id init in din::setup

// mondrian (see mondrian.cc/h)

//

unsigned char mondrian::patbuf [1024] = {0};

string mondrian::patstr = "din is noise";

int mondrian::patstep = 1, mondrian::patlen = mondrian::patstr.length ();

rnd<float> rect::rd (0.0f, 1.0f); // to make box color

int rect::ref = 0, ball::ref = 0, slit::ref = 0;

const float mondrian::gutter = 2;

const float mondrian::gutter2 = mondrian::gutter * mondrian::gutter;

float mondrian::min_split_size = 16;

float slit::HALF_SIZE = 20;

float slit::MIN_HALF_SIZE = 1;

float slit::MIN_SIZE = 2 * slit::MIN_HALF_SIZE;

const char* ball::types_str [4] = {" bouncer", " wrecker", " healer", " bouncer or wrecker or healer"};

const char* ball::trigstr [2] = {"note", "noise"};

float ball::recent_attack_time = 0.01f; // secs

float ball::recent_decay_time = 2.0f; // secs

float ball::recent_pitch_mult = 1.0f; // modulation

const char* mondrian_listener::split_types [3] = {" into 2 boxes", " at notes", " into N boxes"};

const char* mondrian_listener::selection_targets [2] = {"Selection target = slits", "Selection target = balls"};

const char* mondrian_listener::pick_box_types [5] = {" Pick the oldest box", " Pick a random box", " Pick the biggest box", " Pick the youngest box", " Pick a box that has a ball"};

const char* mondrian_listener::auto_split_orient_types [4] = { "", " Split horizontally", " Split vertically", " Split horizontally & vertically"};

const char* mondrian_listener::auto_split_at_types [2] = {" Split at notes", " Split anywhere"};

const double slit::INITIAL_OPEN_CLOSE_TIME = 2.0;

// ball operations

const char* ball_op::names [] = {"All Ops", "Turn", "Speed", "Teleport", "Clone"};

float ball_op::TRIGGERT = 0.1; // seconds

float turn::CLOCKWISE = 60.0f, turn::ANTI_CLOCKWISE = 60.0f; // degrees

float speed::BRAKE = 1, speed::ACCELERATE = 1;

float teleport::MAX_RADIUS = 300.0f;

int Clone::max_balls = 64;

int Transform::rules [3] = {ball::WRECKER, ball::HEALER, ball::BOUNCER};

mondrian mondrian0;

// binaural drones see binaural_drones.cc/h)

//

i_binaural_drones binaural_drones0;

const char* binaural_drones_listener::justs [] = {" Justification = Left", " Justification = Right", " Justification = Center"};

gotog _gotomax (1, &mondrian0.attacked);

// keyboard-keyboard

//

float NOTE_VOLUME = 0.75f * VOICE_VOLUME;

int PITCH_BEND; // in Hz 

float PITCH_BEND_PER_PIXEL;

// in seconds

float ATTACK_TIME = 0.05f;

float DECAY_TIME = 5.0f;

float DELTA_TIME = 0.025f;

keyboard_keyboard keybd2;

gotog _gotog (1, &keybd2.attacked); // default sustain (see keyboard-keyboard.cc)

// available instruments

const char* INSTRUMENTS [] = {"keyboard_keyboard", "microtonal_keyboard", "mondrian", "binaural_drones"};

const char* INSTRUMENTS_SHORT [] = {"kkb", "mkb", "mon", "bd"};

extern const int NUM_INSTRUMENTS = 4, LAST_INSTRUMENT = NUM_INSTRUMENTS - 1;

int CURRENT_INSTRUMENT = 0;

string INSTRUMENT = INSTRUMENTS [CURRENT_INSTRUMENT];

instrument* INSTRUMENT_PTR [] = {&keybd2, &din0, &mondrian0, &binaural_drones0};

checkbutton* LAST_TABS [NUM_INSTRUMENTS] = {0, 0, 0, 0};

mkb_selector_t mkb_selector; // selector for microtonal keyboard with drone mesh preview

box_selector mon_selector; // selector for mondrian

string style_listener::styles [] = {"loop", "pong"};

vector<multi_curve*> curve_list;

void setup_curve_list () {

  multi_curve* lst [] = {

    &din0.wave,

    &keybd2.wave,

    din0.fm.crv,

    din0.am.crv,

    din0.gatr.crv,

    octave_shift.crv,

    &din0.drone_wave,

    &left_delay.fbk_crv,

    &left_delay.vol_crv,

    &right_delay.fbk_crv,

    &right_delay.vol_crv

  };

  for (int i = 0; i < 11; ++i) curve_list.push_back (lst[i]);

}

const char* bpm_com::str [bpm_com::NUM] = {"os", "gr", "am", "fm"};

beat2value* bpm_com::bv [] = {&octave_shift, &din0.gatr, &din0.am, &din0.fm};

#define DEFINE_TCL_FUNC(X) inline int (X) (ClientData cd, Tcl_Interp* ti, int objc, Tcl_Obj* CONST objv[]) { return tcl_run (cd, ti, objc, objv);}

DEFINE_TCL_FUNC(tcl_key)

DEFINE_TCL_FUNC(tcl_setv)

DEFINE_TCL_FUNC(tcl_getv)

DEFINE_TCL_FUNC(tcl_set_delay)

DEFINE_TCL_FUNC(tcl_get_delay)

DEFINE_TCL_FUNC(tcl_set_bpm)

DEFINE_TCL_FUNC(tcl_get_bpm)

DEFINE_TCL_FUNC (tcl_set_beat);

DEFINE_TCL_FUNC (tcl_get_beat);

DEFINE_TCL_FUNC(tcl_set_style)

DEFINE_TCL_FUNC(tcl_get_style)

DEFINE_TCL_FUNC(tcl_set_kern)

DEFINE_TCL_FUNC(tcl_get_kern)

DEFINE_TCL_FUNC(tcl_set_font_size)

DEFINE_TCL_FUNC(tcl_get_font_size)

DEFINE_TCL_FUNC(tcl_note_distance)

DEFINE_TCL_FUNC(tcl_chord)

DEFINE_TCL_FUNC(tcl_notation)

DEFINE_TCL_FUNC(tcl_echo)

DEFINE_TCL_FUNC(tcl_curve_value)

DEFINE_TCL_FUNC(tcl_curve_name)

DEFINE_TCL_FUNC(tcl_curve_library)

DEFINE_TCL_FUNC(tcl_morse_code)

DEFINE_TCL_FUNC (tcl_set_editor);

DEFINE_TCL_FUNC (tcl_set_kb_layout);

DEFINE_TCL_FUNC (tcl_set_scope);

DEFINE_TCL_FUNC (tcl_get_scope);

DEFINE_TCL_FUNC (tcl_get_drone);

DEFINE_TCL_FUNC (tcl_set_drone);

DEFINE_TCL_FUNC (tcl_text_color);

DEFINE_TCL_FUNC (tcl_paste_gater);

DEFINE_TCL_FUNC (tcl_get_intervals);

DEFINE_TCL_FUNC (tcl_num_octaves);

DEFINE_TCL_FUNC (tcl_set_audio);

DEFINE_TCL_FUNC (tcl_load_scale);

DEFINE_TCL_FUNC (tcl_scale_curve);

DEFINE_TCL_FUNC (tcl_binaural_drone);

DEFINE_TCL_FUNC (tcl_set_sine_mixer);

DEFINE_TCL_FUNC (tcl_change_sine_mixer);

DEFINE_TCL_FUNC (tcl_update_sine_mixer);

DEFINE_TCL_FUNC (tcl_write_svg);

DEFINE_TCL_FUNC (tcl_write_trail);

// din commands

//

// format: long name, short name

// for L and R delays

set_delay sd (&left_delay, &right_delay, "set-delay", "sd");

get_delay gd (&left_delay, &right_delay, "get-delay", "gd");

// to load the scale

load_scale los (&din0, "load-scale", "los");

// set and get din variables

set_var sv (&din0, "set-var", "sv");

get_var gv (&din0, "get-var", "gv");

// bpm commands

//

set_bpm sb ("set-bpm", "sb");

get_bpm gb ("get-bpm", "gb");

set_beat sn ("set-beat", "sbt");

get_beat gn ("get-beat", "gbt");

set_style ss ("set-style", "ss");

get_style gs ("get-style", "gs");

int doublebpm = 0;

float BPM_MULT = 2.0f;

// set key/tonic

key ky (&din0, "key", "key");

// display notation on the keyboard

notation no (&din0, "notation", "no");

// music utils

note_distance nd ("note-distance", "nd");

chord ch ("chord", "ch");

// font cmds

set_font_size sfs ("set-font-size", "sfs");

get_font_size gfs ("get-font-size", "gfs");

set_kern sk ("set-kern", "sk");

get_kern gk ("get-kern", "gk");

// curve cmds

curve_name cn ("curve-name", "cn");

curve_value cv ("curve-value", "cv");

curve__library cl ("curve-library", "cl");

set_curve_editor sced ("set-curve-editor", "sced");

paste_gater pasg ("paste-gater", "paste-gater");

scale_curve scrv ("scale-curve", "scrv");

// morse code

morse_code mc ("morse-code", "mc");

// to replace curves in a multi curve with a seed curve

fractaliser fractaliser_;

// to generate curve from polar equation R = sin (K * theta)

rose_milker rosemilker;

// to generate a regular polygon

circler circler_;

// to generate a spiral with R = A * theta

spiraler spiraler_;

// to connect dots to make star polygons

starrer starrer_;

// to generate lissajous curve

lissajous lissajous_;

// to generate superformula curve

superformula superformula_;

// to warp XY of segments of a curve

warper warper_;