Subversion Repositories DIN Is Noise

/*

* curve_editor.h

* 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/

*/

#ifndef __curve_editor

#define __curve_editor

#include <vector>

#include <map>

#include <list>

#include <string>

#include <fstream>

#include "curve.h"

#include "multi_curve.h"

#include "basic_editor.h"

#include "curve_listener.h"

#include "curve_samples.h"

#include "ui.h"

#include "mocap.h"

#include "beat2value.h"

#include "box_selector.h"

#include "curve_picker.h"

#include "checkbutton.h"

#include "state_button.h"

#include "capturer.h"

#include "point_modulator.h"

#include "hit.h"

#include "help.h"

#include "angle.h"

struct multi_curve;

struct curve_editor;

struct curve_library;

struct plugin;

struct mouse_macro {

  // for applying mouse capture to hit vertex/tangent of hit curve

  mocap mo; // mouse capture data

  hit_t hit; // hit curve & vertex/tangent

  state_button* sb; // button on capturer widget

  int paused;

  mouse_macro (const mocap& m, hit_t& h, state_button* b) : mo(m), hit(h), sb(b) { paused = 0;}

};

struct undo_t {

  int i;

  multi_curve curve;

  window win;

  undo_t (int ii, const multi_curve& mc, window& w) : i(ii), curve(mc), win(w) {}

};

typedef undo_t redo_t;

struct curve_info {

  multi_curve* curve;

  curve_listener* lisner;

  int picked;

  int visible;

  // auto rotation

  float lastrpm;

  float angle;

  float totang;

  int dir;

  int autoflip;

  anglet every0, every;

  int randoflip;

  rnd<float> rd;

  void randeg () { every = rd () * every0.deg; }

  double startt;

  curve_info  (multi_curve* c, curve_listener* l, int picked = 0);

  curve_info ();

  void init ();

};

struct curve_editor : basic_editor {

  // edited curves

  //

  std::vector <curve_info> curveinfo;

  int curves;

  int curcrv;

  int curcrvchgd;

  int visibles;

  int setcrvvis (int i, int v);

  int onecurve () { return (curves == 1 || visibles == 1); }

  int savedrots;

  void add (multi_curve* crv, curve_listener* lsnr);

  void clear ();

  multi_curve* get_curve (int i);

  // curve editor features

  //

  int carry_tangents; // when vertex moves, their tangents move too.

  int mirror_tangents; // when 1 tangent of a vertex moves, the other moves too.

  // picking

  //

  std::vector <hit_t> hitlist;

  hit_t pik;

  multi_curve* get_picked_curve ();

  hit_t pick_cur_curve ();

  void set_picked_curve_name (const std::string& n);

  void curve_picked ();

  void hilite_item (int id);

  void hittest (multi_curve* crv, int crv_id, const points_array& points, unsigned int what);

  void hittest ();

  int filter_hitlist ();

  void clear_hit (hit_t& h);

  void calc_hit_params (hit_t& h);

  void set_pick_from_hitlist (int i);

  void picked_using_picker (int i);

  // vertex/tangent operations

  //

  enum {

    NOTHING = 0,

    MOVE_PICKED,

    MOVE_ALL,

    PICK_CURVE,

    INSERT_VERTEX,

    REMOVE_VERTEX,

    FOLD_SELECTED,

    UNFOLD_SELECTED,

    FOLD_ALL,

    UNFOLD_ALL,

    MIRROR_VERTEX,

    MIRROR_ALL,

    COPY,

    PASTE,

    ADD_VERTEX,

    START_CAPTURE,

    ASSIGN_CAPTURE,

    REMOVE_CAPTURE,

    MODULATE_POINT,

    PICK_TANGENT,

    SIZE_TANGENT,

    PINUNPIN,

  };

  void try_sizing_tangent ();

  void start_sizing_tangent ();

  void size_tangent (float s);

  int todo;

  int next_todo;

  int stop_todo ();

  void abs_nothing ();

  void quick_nothing (int lm = 0);

  void do_pick_curve ();

  int lmb_move;

  enum {PREP = 1, FINISH_ON_CLICK = 2};

  void prep_move ();

  int move ();

  int move (int);

  int move (hit_t& hit, float x, float y, int eval_now = 1);

  multi_curve& set_mix_undo (hit_t& h);

  void fold_tangents_using_menu ();

  void fold_all_tangents (hit_t& h);

  void fold_tangents_of_vertex (hit_t& h);

  void pinunpin_using_menu ();

  void pinunpin ();

  void insert ();

  void insert_using_menu ();

  void remove ();

  void remove_using_menu ();

  enum {MIRROR_X = 0, MIRROR_Y, MIRROR_BBX, MIRROR_BBY};

  int axis;

  void mirror (int whole_curve = 0);

  void mirror_using_menu ();

  void set_limit (float f);

  void copy_curve ();

  void copy_using_menu ();

  void replace ();

  void paste_using_menu ();

  void swap ();

  // scratch curve

  //

  int show_scratch_curve;

  points_array win_scratch_points, curv_scratch_points;

  multi_curve scratch_curve;

  void clear_scratch_curve ();

  void draw_scratch_curve ();

  void draw_replacement_curve_using_menu ();

  void add_vertex ();

  // load and save editor settings

  std::string settings_filename;

  // undo, redo

  //

  std::list <undo_t> undos;

  std::list <redo_t> redos;

  void dodo (std::list<undo_t>& do1, std::list<undo_t>& do2, std::string mesg);

  void do_undo ();

  void do_redo ();

  // copy, paste, paste append

  static multi_curve copy;

  void paste (hit_t& h);

  void paste_append (multi_curve& to, multi_curve& from);

  // curve library

  //

  curve_library* library;

  void add_curve ();

  void replace_curve ();

  void insert_curve ();

  void delete_curve ();

  void load_curve (int dir);

  void do_load_curve (int dir);

  // mouse capture

  //

  std::vector<mouse_macro> macros;

  capturer_t capturer;

  void start_mouse_capture_from_menu ();

  void assign_mouse_capture ();

  void assign_mouse_capture_from_menu ();

  void remove_mouse_capture (state_button* sb);

  void toggle_mouse_capture (std::vector<state_button*>& caps);

  // point modulation

  point_modulator pomo;

  void modulate_point ();

  void modulate_point (int);

  // settings

  //

  curve_editor (const std::string& settingsf);

  ~curve_editor ();

  void load (const std::string& fname);

  void save ();

  // ui

  int handle_input ();

  // curve selection ops

  void toggle (int k);

  void enable (int k);

  void enable_all ();

  int one_curve_enabled ();

  std::string selection ();

  // drawing

  //

  int drawcurve;

  void draw_curve (multi_curve* crv);

  void draw_curves ();

  int draweditables;

  void draw_tangents (multi_curve* crv);

  void draw_vertices (multi_curve* crv);

  void draw_vertices ();

  void draw_tangent (const point<float>& p, const point<float>& t);

  void draw_tangents ();

  void draw_handle (const point<float>& p);

  void draw_all ();

  void draw ();

  int draw_plugin_output;

  int marksegments;

  void mark_segments ();

  int guides;

  void draw_guides ();

#ifdef __SVG__

  // svg

  void write_curve (multi_curve* crv, std::ofstream& svg, float w, float h, float t, float left, float top, box<float>& bb);

  void write_svg (float h, float t, const std::string& fn, float left, float top);

  void write_samples (std::ofstream& svg);

#endif

#ifdef __HPGL__

  // hpgl

  void write_curve (multi_curve* crv, std::ofstream& hpgl, float scale, float penmag);

  void write_hpgl (float scale = 5000, float penmag = 100);

#endif

  void attach_library (curve_library* lib);

  void enter ();

  void bg ();

  void set_curve_style (multi_curve* crv);

  void toggle_curve_style ();

  void apply_mocap ();

  void apply_mocap (mouse_macro& m, int dir = 1);

  int fft_enabled;

  int waved;

  int samples_enabled;

  float hz;

  int nperiods;

  int offset;

  curve_samples cs;

  void set_hz (float zh);

  void set_periods (int p);

  void toggle_waveform_samples_display ();

  void render_curve_samples ();

  std::vector<beat2value*> bv;

  int label_vertices;

  void toggle_vertex_labels ();

  int overlay;

  std::string next_cursor_mesg;

  void setup_tools_menu ();

  void set_rpm (float r);

  void rotate ();

  void scale (float sx, float sy);

  void apply_plugin (plugin* p);

  int hlabel_only;

  int mkr[8];

  void calc_visual_params ();

  multi_curve mix;

  static help helptext;

  static color vtxlbl;

  int esc ();

  void drawerlay ();

  int lmb_clicked;

  int beater;

  void do_powbeat (float mult);

};

extern curve_picker_t curve_picker;

void show_curve_picker ();

#define CRVED uis.crved 

#endif