curvecalc, with all curves:

  music                  /\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\/
  music_smooth           /\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\//\/\/
  slider1 (song02)
  slider2 (end_scene)
  slider3 (cyc)
  pad1x (effect_strobe)
  pad1y (effect_strobe[rate])
  pad1p
  
-----------------------------------------------------------------------------------------------------------
curvedb has access to the curves and can write them. temporary edit
state like the selection and view area is held in the gui. curvedb
ensures that points have increasing and unique times. api:

  observable visibleCurves(song), can change later
  
  getRange(curve, t1, t2) may also take resolution. this is for gui to
    draw and for effect preview to show off an effect.  also returns
    markers

  liveInputPoint(curve, t, value) a controller has asked for this value. wipe out old points as appropriate.

  addPoint(curve, t, value) a gui has added a point. this may cause a new curve to start existing.

  movePoint(curve, t, newT, newValue) gui has tried to edit a point. we might not allow it.

  transformPoints(curve, ts, scale, newStart, newEnd, newWidth) multi-point operations. input point list by their times.

  observable curveUpdated(curve) curve or marker data changed. This might return a version number for the curve data.
  
-----------------------------------------------------------------------------------------------------------
curveedit draws the curves and manages selection. It draws current
playback time. Song->curves mapping comes from rdfdb. current playback probably does too.

  state:
    song
    viewRange times

    currentCurve: for highlighting on gui or quneo when you edit it
    selection: points on curves, but do they have to get updated
      constantly as you drag them around? could use pt indices but
      that might get awkward at other resolutions
    
    graphs (each graph may have multiple curves in it)

  api:
    selectPoint(curve, t)

    startRangeSelect(curve, t)
    dragRangeSelect(curve, t)
    endRangeSelect(curve, t)

edit markers too.
    
mute happens in here? maybe i never used it.
    
rows never scroll out of view; they can just get very tiny. maybe
support multiple curves in the same row, like for one effect.

rows appear when you use them in the song.

from a curve you need to see what effects use it. just a single intensity on a single sub is a common case.

-----------------------------------------------------------------------------------------------------------
data model:

show
  controlMapping (describes how this control should initially behave in a song)
    [
      control: pad5
      effect: [
        type: chase
        code: out ???? don't know curves yet
      ]
    ]

song1
  controlMapping
    [
      control: pad5
      curve: curve1
    ]
  row1 (only used for display)
    curve1
  curve1
    points
  effect1
    type: sub
    code: out = sub('stageleft', intensity=curve1)
  effect2
    type: sub
    code: out = sub('stageright', intensity=curve2)
  effect3
    type: chase
    code: out = ... (curve3)

-----------------------------------------------------------------------------------------------------------
many controls are mapped to standard subs or effects.


using an unmapped slider gives you a default (or random) new sub, to be changed later to the right look.

touching anything should accent its row in curvecalc; touching a CC row shuold light up its pad on quneo.

touching anything starts recording it. when you let go, points stop
being made, and they might connect to what was there before. when
you're holding a pad down at all, existing points you pass over get
deleted. sliders have this too, but instead of reading pad pressure,
they have a fixed amount of time that they erase after each value
change (and no slider output is attempted).

CC expressions are drawn in their rows. most exprs are no

row structure (settings are per-song):
  input controller name (slider1 or pad1x)
  points: ...
  connect_to_input: song01.intensity
   or
  connect_to_input: chase.offset
   or
  connect_to_input: chase.speed

  you can connect to multiple inputs.


a thing to be able to do quickly:

  have

    slider1 -> song02.intensity: ___/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\___

  want to add in some silhouette, so we need this new mapped curve row:

    slider1 -> song02.intensity: ___/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\___
    slider8 -> silhouette0.intens: __________________________________________

  then i animate to this:

    slider1 -> song02.intensity: ___/~~~~~~~~~~~\___/~~~~~~~~~~~~~~~~~~~\___
    slider8 -> silhouette0.intens: _____________/~~~\_______________________

  to add that row, i went to CC, 'add row', picked from not-yet-used
  input controls, picked from all the effect types (including subs),
  made a new instance of silhouette, and made a new row that's all
  zeros.

  Input picker:
  +------------------------------------------------------------+
  | Existing nodes:                                            |
  |   song02                                                   |
  |   cyc                                                      |
  |   blink0                                                   |
  |     + intensity                                            |
  |     + term1                                                |
  |     + term2                                                |
  |                                                            |
  | Make new node (and connect to its 'intensity' input):      |
  |   blink                                                    |
  |   song03                                                   |
  |   song04                                                   |
  +------------------------------------------------------------+


-----------------------------------------------------------------------------------------------------------

separate effect program:

goals:
  visualize effects, including time-based ones
  make new expression effects

state:
  current effect being shown (follows the last-touched effect in curvecalc, or you can pick one)


vis of a chase effect (readonly):

  beat   |     |     |     |     |     |     |     |     |
  chan1  __/~~\__/~~\__/~~\__/~~\__/~~\__/~~\__/~~\__/~~\
  chan2  ___/~~\__/~~\__/~~\__/~~\__/~~\__/~~\__/~~\__/~~\

  you'd edit the incoming offsets, fade speeds, etc according to what the effect supports.

  this ui also shows you what input params you could be editing, and what quneo sliders they're mapped to:

    ( ) ( )
    | | | |
    | | | |

    cyc_strobe effect mapping:
      padx "music sensitivity"
      pady "intensity"
      slider1 "music time offset"
      slider2 "sustain"
      slider3 "side separation"

vis of a rgb effect:

   color1:  (rgb stripes)
   color2:  (rgb stripes)

-----------------------------------------------------------------------------------------------------------

blink to music:


'blink' sub effect:
  subs: [cyc]
  intensity: (envelope curve)
  term1: (music curve)
  term2: (another curve)
  term3:

  output = intens * (term1 + term2 + term3)


-----------------------------------------------------------------------------------------------------------

quneo settings UI webpage:

shows pad mappings.
-----------------------------------------------------------------------------------------------------------

how do you make a button that drops the stage to just blue light?

is a Pi camera good for taking stage shots? or just my DSLR?

see inputmapping.html