Goniometer (Tukan)

desc: Goniometer (Tukan)
// Version 1.1.1

MIT License

Copyright (c) 2019 chokehold

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
in_pin:left input
in_pin:right input
out_pin:none
//options:no_meter

slider1:view=1<0,2,1{Dots,Lines,Rays}>-Visualization
slider2:tint=143<0,255,0.01>-Colour
slider3:glow=1<0,1,1{Off,On}>-Glow
slider4:axes=5<0,3,1{None,Left/Right,Left/Right + Decibels,Mid/Side,Mid/Side + Decibels,Left/Right + Mid/Side + Decibels}>-Indicators
slider5:labels=0<0,1,1{Off,On}>-Labels
slider6:freeze=2<0,2,1{Off,On,Stop/Pause}>-Freeze
slider7:0.7<0.3,0.95,0.05>-Speed
slider8:0<0,30,.1>-Scaling

filename:0,Scopegui/scopeback.png
filename:1,Scopegui/4step.png
filename:2,Scopegui/APIBig.png

@init









  //gfx_clear=0;
  ext_noinit=1;
  lastCap=1;
  mouse_wheel=1;
  coords=srate+1;
  initial = 0;
  
      function limitgui(s low up)
                  ( min(max(s, low), up) );
    function deg(r)
                  ( r / $pi * 180 );
    function rad(d)
                  ( d * $pi / 180 );
                  
                  
 /******************************* GUI Function ***********************************/
    function xy(x y)
               ( gfx_x = x; gfx_y = y; );
    
    function rgb(r g b)
                ( gfx_r = r; gfx_g = g; gfx_b = b; );
    
    function rectIn  (xIn_ yIn_ wIn hIn)
      instance       (xIn yIn widthIn heightIn)
                     (
                      xIn = xIn_;
                      yIn = yIn_;
                      widthIn = wIn;
                      heightIn = hIn;
                      );
                    
    function rectOut  (xOut_ yOut_ wOut hOut c i)
      instance        (xOut yOut widthOut heightOut count index)
                      (
                       xOut = xOut_;
                       yOut = yOut_;
                       widthOut = wOut;
                       heightOut = hOut;
                       count = c;
                       index = i;
                       );                
    
    function potVal(v)
      instance      (frame val minVal maxVal count heightOut)
                    (
                     val = v;
                     frame = (val - minVal) * (count - 1) / (maxVal - minVal) + 0.5;
                     frame |= 0;
                    );
    
    function potCfg  (default_ minVal_ maxVal_ step_)
      instance        (default minVal maxVal step)
                      (
                       default = default_;
                       minVal = minVal_;
                       maxVal = maxVal_;
                       step    = step_;
                       this.potVal(default);
                      );
  
    function bkg(wImg hImg indImg)
                 (
                   gfx_a=1;
                   coords[0] = coords[4] = 0;
                   coords[1] = coords[5] = 0;;
                   coords[2] = coords[6] = wImg;
                   coords[3] = coords[7] = hImg;
                   gfx_blitext(indImg, coords, 0);
                  ); 
    
    function potDrawIn ()
      instance        (xIn yIn widthIn heightIn val)
                      (
                         gfx_r= 1; gfx_g = gfx_b =0;gfx_a= 0.5;
                         
                         gfx_line(xIn,yIn,xIn,heightIn+yIn);
                         gfx_line(xIn,heightIn+yIn,xIn+widthIn,heightIn+yIn);
                         gfx_line(xIn+widthIn,yIn,xIn+widthIn,heightIn+yIn);
                         gfx_line(xIn,yIn,xIn+widthIn,yIn);
          
                         gfx_r = gfx_g = gfx_b = 0.75;
                         gfx_x = xIn + widthIn/2-12;
                         gfx_y = yIn+heightIn/2-5;
                         gfx_drawnumber(val, 1);                   
                      );
    
    function knob()
      instance   (xOut yOut widthOut heightOut index frame val)
                 (
                  
                   gfx_a=1;
                   coords[0] = 0;
                   coords[1] = frame * heightOut;
                   coords[2] = coords[6] = widthOut;
                   coords[3] = coords[7] = heightOut;
                   coords[4] = xOut;
                   coords[5] = yOut;
                   gfx_blitext(index, coords, 0);
                  );                                     
    
    function collision  ()
      instance          (xIn yIn widthIn heightIn)
                        (
                         mouse_x > xIn && mouse_x < xIn + widthIn && mouse_y > yIn && mouse_y < yIn + heightIn
                        );
    
    function dragStart ()
      instance          (dragging yOld default)
                        (
                         !ctrl ? (
                         yOld = mouse_y;
                         dragging = 1;
                        ) : 
                         this.potVal(default);
                        );
    
    function dragStop()
      instance        (dragging val valOld)
                      (
                       dragging = 0;
                       valOld = val;
                      );
    
    function potDrag()
          local      (val)
            instance   (valOld minVal maxVal yOld step)
                     (
                       !shift ? (
                       mstep = (this.maxval - this.minval)/100;
                      val = valOld + (yOld - mouse_y) * mstep;
                      val = limitgui(val, minVal, maxVal);
                      this.potVal(val);
                      ):(
                      val = valOld + (yOld - mouse_y) * step;
                      val = limitgui(val, minVal, maxVal);
                      this.potVal(val);
                      );
                     );
                     
    function potToggle()
          local      (val)
            instance   (valOld minVal maxVal yOld step)
                     (
                      valold == 0 ? (val = 1):(val=0);
                      val = limitgui(val, minVal, maxVal);
                      this.potVal(val);
                      valOld=val;
                       );
    
    function potWheel()
        local         (val)
        instance      (valOld minVal maxVal step)
                      (
                      mstep = (this.maxval - this.minval)/100;
                       val = valOld + (mouse_wheel/36)*mstep;
                       val = limitgui(val, minVal, maxVal);
                       this.potVal(val);
                       valOld=val;
                       mouse_wheel=0;
                        );
 
   
 front.potcfg  (0,0,30,.03);
 
 front.rectIn(350, 40, 75, 75);
 front.rectOut(350, 40, 75, 75, 4, 1);

 center.potcfg(0.7,0.3,0.95,0.00092);

 center.rectIn(350, 160, 75, 75);
 center.rectOut(350, 160, 75, 75, 61, 2);











































  // Simple hard clipping
  //
  function clamp (signal) (max(-1, min(1, signal)));
  
  // Some radian constants to minimize per-sample calculations
  quarterPi = $PI * 0.25; //  45°
  pi        = $PI;        // 180°
  oneDot5Pi = $PI * 1.5;  // 270°
  twoPi     = $PI * 2.0;  // 360°
  
  // At 786 kHz sample rate, 20 ms = 15270 samples,
  // so 20000 samples buffer should be sufficient.
  //
  historyX = 10000; // Stores X coordinates
  historyY = 30000; // Stores Y coordinates
  numCoords = ceil(srate * 0.05); //0.05  # of samples ~20 ms window
  lastCoord = numCoords - 1; // To save calculations later
  
  // Things related to the display drawing colours
  //
  colourRange = 85; // Fader 0-255 --> 255/3 = 85
  colourR = 1; // Red colour default amount [0,1]
  colourG = 0; // Green colour default amount [0,1]
  colourB = 0; // Blue colour default amount [0,1]
  colourA = 0.75; // Alpha/transparency amount fixed
  //
  function setAxisHardColour () (gfx_set(1,1,1,0.4));
  function setAxisSoftColour () (gfx_set(1,1,1,0.2));
  function setDecibelColour  () (gfx_set(1,1,1,0.1));
  function setLabelColour    () (gfx_set(1,1,1,0.25));
  //
  // This sets the drawing colour of the display
  //
  // The UI fader ranges between [0,255] and its range is split into
  // three sections of an equal third (=85) each. In every section,
  // one colour is totally out and the two remaining colours fade in
  // opposite directions, i.e. one gets stronger and one drops off.
  //
  // Colour amount calculations implemented after FastLED "Spectrum"
  // hue chart rather than "Rainbow", merely for its simplicity.
  // https://github.com/FastLED/FastLED/wiki/FastLED-HSV-Colors
  // https://raw.githubusercontent.com/FastLED/FastLED/gh-pages/images/HSV-spectrum-with-desc.jpg
  //
  function tintColour () local (fraction)
  (
    // Positions 0 and 255 are always Red,
    // so no calculations necessary here.
    tint % 255 == 0 ?
    (
      colourR = 1; // full
      colourG = 0; // out
      colourB = 0; // out
    );
    
    // First third of the colour range:
    // Red falls, Green rises, no blue
    (tint > 0) && (tint < 85) ?
    (
      // How far into this third of 85 is
      // the fader, result in range [0,1]
      fraction = tint / 85;
      
      colourR = 1 - fraction; // fall
      colourG = fraction; // rise
      colourB = 0; // out
    );
    
    // Second third of the colour range:
    // No red, Green falls, Blue rises
    (tint >= 85) && (tint < 171) ?
    (
      // How far into this third of 85 is
      // the fader, result in range [0,1]
      fraction = (tint - 84) / 85;
      
      colourR = 0; // out
      colourG = 1 - fraction; // fall
      colourB = fraction; // rise
    );
    
    // Last third of the colour range:
    // Red rises, no Green, Blue falls
    (tint >= 171) && (tint < 255) ?
    (
      // How far into this third of 85 is
      // the fader, result in range [0,1]
      fraction = (tint - 170) / 85;
      
      colourR = fraction; // rise
      colourG = 0; // out
      colourB = 1 - fraction; // fall
    );
  );
  
  // This will take a regular set of L/R samples and turn them
  // into a set of X/Y coordinates for placement on the scope.
  // 
  // The samples are turned into polar coordinates, this gives
  // a rotational angle and the distance from the center, from
  // which the carthesian X/Y coordinates are then calculated.
  // 
  // Since this effect has no output pins, it's not necessary
  // to copy the input samples to variable containers, instead
  // the processing will be performed directly on the samples.
  //
  function calculateCoordinates () local (radius, angle)
  (
    // Calculate polar coordinate from input samples
    radius = sqrt(sqr(spl0) + sqr(spl1));
    angle  = atan(spl1 / spl0);
    
    // Arctan doesn't like it if the samples are zero or lower,
    // so compensate the angle if that happens to be the case.
    angle += ((spl0 < 0 && spl1 != 0) * pi) + ((spl0 > 0 && spl1 < 0) * twoPi);
    spl0 == 0 ? angle = oneDot5Pi - (spl1 > 0) * pi;
    spl1 == 0 ? angle = (spl0 <= 0) * pi;
    
    // To make the scope display upright, add 45° to the angle
    angle += quarterPi;
    
    // Convert polar coordinate to cartesian X/Y coordinate
    spl0 = (radius * cos(angle)); // X value
    spl1 = (radius * sin(angle)); // Y value
  );
  
  // Move everything in the history back one step and add the
  // latest samples at the end. At this point, the values are 
  // not the input samples anymore, but their X/Y coordinates.
  //
  function addToHistory ()
  (
    // Shift buffers -1 i.e. to the left, loses the last value
    memcpy(historyX, historyX+1, numCoords);
    memcpy(historyY, historyY+1, numCoords);
    
    // Insert the latest values at the back of the buffers
    historyX[lastCoord] = spl0;
    historyY[lastCoord] = spl1;
  );
  
  // Paints the L/R, M/S, dB guides and labels onto the canvas
  //
  function drawIndicators () local (top, left, right, bottom, middleH, middleV)
  (
    // Switch to the main screen buffer
    gfx_dest = -1;
    
    // Draw L/R indicator axes
    //
    (axes == 1 || axes == 2 || axes == 5) ?
    (
      // Convenience variables for code readability
      top    = centerY - viewScale + 1;
      left   = centerX - viewScale + 1;
      bottom = centerY + viewScale;
      right  = centerX + viewScale;
    
      // Draw L/R axis guides
      setAxisHardColour();
      gfx_line(left, top, right, bottom, 1);
      gfx_line(left, bottom, right, top, 1);
      
      // Draw L/R labels
      labels == 1 ?
      (
        setLabelColour();
        gfx_y = top - 11;
        gfx_x = left - 12;
        gfx_drawstr("L");
        gfx_x = right + 6;
        gfx_drawstr("R");
      );
    );
    
    // Draw Mid/Side indicator axes
    //
    (axes == 3 || axes == 4 || axes == 5) ?
    (
      // Convenience variables for code readability
      top     = centerY - viewSize;
      left    = centerX - viewSize;
      bottom  = centerY + viewSize;
      right   = centerX + viewSize;
      middleH = centerX; // Horizontal = left/right
      middleV = centerY; // Vertical = up/down
      
      // Draw M/S axis guides (softer if mixed with L/R axes)
      axes == 5 ? setAxisSoftColour() : setAxisHardColour();
      gfx_line(left, middleV, right, middleV, 1);
      gfx_line(middleH, top, middleH, bottom, 1);
      
      // Draw M/+S/S- labels
      labels == 1 ?
      (
        setLabelColour();
        gfx_x = centerX + 8;
        gfx_y = centerY + viewSize - 15;
        gfx_drawstr("M");
        gfx_y = centerY + 7;
        gfx_x = centerX - viewSize + 6;
        gfx_drawstr("+S");
        gfx_x = centerX + viewSize - 22;
        gfx_drawstr("S-");
      );
    );
    
    // Draw dB indicator rings and labels
    //
    (axes == 2 || axes == 4 || axes == 5) ?
    (
      //  0 dBfs = 1.0 * viewSize = as far out as it will go
      //
      gfx_set(1, 1, 1, 0.4);
      gfx_circle(centerX, centerY, viewSize, 0, 1);
      labels == 1 ?
      (
        setLabelColour();
        gfx_y = centerY + viewScale - 4;
        gfx_x = max(centerX - viewScale - 19, 6);
        gfx_drawstr("0");
      );
      
      //
      // -3 dBfs = 0.7079457844
      //
      gfx_set(1,1,1,0.175);
      gfx_circle(centerX, centerY, viewSize * 0.7079457844, 0, 1);
      labels == 1 ?
      (
        //setLabelColour();
        gfx_y = centerY + viewScale * 0.7079457844 - 6;
        gfx_x = max(centerX - viewScale * 0.7079457844 - 28, 6);
        gfx_drawstr("-3");
      );
      
      //
      // -6 dBfs = 0.5011872336
      //
      gfx_set(1,1,1,0.15);
      gfx_circle(centerX, centerY, viewSize * 0.5011872336, 0, 1);
      labels == 1 ?
      (
        //setLabelColour();
        gfx_y = centerY + viewScale * 0.5011872336 - 6;
        gfx_x = max(centerX - viewScale * 0.5011872336 - 28, 6);
        gfx_drawstr("-6");
      );
      
      //
      // -12 dBfs = 0.2511886432
      //
      gfx_set(1,1,1,0.1);
      gfx_circle(centerX, centerY, viewSize * 0.2511886432, 0, 1);
      labels == 1 ?
      (
        //setLabelColour();
        gfx_y = centerY + viewScale * 0.2511886432 - 5;
        gfx_x = max(centerX - viewScale * 0.2511886432 - 35, 6);
        gfx_drawstr("-12");
      );
      
      //
      // -24 dBfs = 0.06309573445
      //
      gfx_set(1,1,1,0.075);
      gfx_circle(centerX, centerY, viewSize * 0.06309573445, 0, 1);
      //
      // Leaving out -24 dBfs label because too compact
    );
  );
  
  // Draws the sample history visualizations
  //
  // Blurring the main screen buffer would not just blur the history
  // display, but also the indicators and labels. To avoid this, the
  // history display will be drawn onto a separate off-screen buffer
  // first, so it doesn't mix with the axes and labels. If no "glow"
  // is required, the off-screen buffer can be blitted directly onto
  // the main screen buffer. If "glow" activated, blit the unblurred
  // history display to yet another off-screen buffer first, blur it
  // there, and finally blit it back to the unblurred buffer and mix
  // them in alpha, i.e. make both partially transparent so they add
  // up to an evenly lit image.
  // 
  function drawHistory () local (dim, coord, offsetX, offsetY, posX, posY, lastX, lastY, thisR, thisG)
  ( 
    // Switch to off-screen frame buffer. Don't clear it, so
    // the last calculated history is still contained there.
    gfx_dest = 127;
    gfx_setimgdim(127, gfx_w, gfx_h);
    
    // Dim the existing history that's still in the buffer.
    // If "glow" activated, dimming can/should be faster so
    // the mix of the two doesn't accumulate too much after
    // a few seconds. The image should not dim/decay while
    // the display is "frozen".
    (freeze != 1 && stopped != 1) ?
    (
      dim = slider7;//(glow == 1 ? 0.925 : 0.98);
      gfx_muladdrect(0,0,gfx_w,gfx_h, dim, dim, dim);
    );
    
    // Iterate through all buffered coordinates in the history
    coord = lastCoord;
    while
    (
      // Calculate this point's position in relation to X/Y center
      offsetX = (historyX[coord] * viewScale*(floor(0.5+(slider8/10))+1));
      offsetY = (historyY[coord] * viewScale*(floor(0.5+(slider8/10))+1));
      
      // Set the drawing position
      offsetY > 0 ? (
        offsetY = min(127,offsetY);
      ):(
        offsetY = max(-127,offsetY);
      );
      offsetX > 0 ? (
        offsetX = min(127,offsetX);
      ):(
        offsetX = max(-127,offsetX);
      );
      gfx_x = centerX - offsetX;
      gfx_y = centerY - offsetY;
      
      // History colour
      gfx_set(colourR, colourG, colourB, colourA, 127);
      
      // Draw point onto graph
      view == 0 ? (gfx_setpixel(colourR, colourG, colourB));
      view == 1 ? (gfx_line(lastX, lastY, gfx_x, gfx_y, 1));
      view == 2 ? (gfx_lineto(centerX, centerY, 1));
      
      // Save current coordinates so can be referred
      // to in next iterations when drawing lines.
      lastX = gfx_x;
      lastY = gfx_y;
      
      // Decrement iterator
      (coord -= 1) > -1;
    );
    
    // Blit the image from the off-screen buffer back to the 
    // main buffer, i.e. plugin GUI. If "glow" active, lower
    // the blitting opacity as the intensity will accumulate
    // when mixed with the later blitted "glow" image buffer.
    gfx_dest = -1;
    gfx_x = gfx_y = 0;
    gfx_a = 1;//(glow == 1 ? 0.7 : 1.0);
    gfx_blit(127,1,0);
    
    // If the history display should "glow"
    glow == 1 ?
    (
      // Blit currently unblurred image to off-screen buffer
      gfx_dest = 100;
      gfx_setimgdim(100, gfx_w, gfx_h);
      gfx_a = 1.0; // full opacity before blurring
      gfx_x = gfx_y = 0;
      gfx_blit(127,1,0);
      
      // Blur it a few times, more blur runs = faster decay.
      gfx_x = gfx_y = 0;
      gfx_blurto(gfx_w, gfx_h);
      gfx_x = gfx_y = 0;
      gfx_blurto(gfx_w, gfx_h);
      gfx_x = gfx_y = 0;
      gfx_blurto(gfx_w, gfx_h);
      
      // Switch to the main buffer and blit the now blurred
      // visualization on top of what's already there, i.e.
      // indicators and un-blurred visualization.
      gfx_dest = -1;
      gfx_a = 0.3;
      gfx_x = gfx_y = 0;
      gfx_blit(100,1,0);
    );
  );





  attack = exp(-1/(3/1000*srate));
  release = exp(-1/(1000/1000*srate));
  decay = 1/srate/0.6;
  k=sqrt(2);
  function GFXClear () (
  gfx_x=gfx_y=gfx_r=gfx_g=gfx_b=0; gfx_a=1;
  gfx_rectto(gfx_w,gfx_h)
  );
  gfx_clear=-1;
  p=$PI/180;
  c=1;
  s=0;
  i=0;
  Corr=1;
  Indicar=1;

decay*=slider7*4;


@slider
  
  // Recalculate the RGB colours to tint the display
  tintColour();
  
@block
  
  // Triggers a display freeze when project is stopped 
  // or paused in "Play/Pause" freeze mode. Responsive
  // enough if this is switched in the @block section.
  stopped = (freeze == 2 && play_state < 1) ? 1 : 0;
  stopped = 0;
@sample
  
  // If the display is frozen, don't calculate any new
  // samples and don't mess with the history buffers.
  (freeze != 1 && stopped != 1) ?
  (
    calculateCoordinates();
    addToHistory();
  );
  // Bufering input
    inl=spl0;
  inr=spl1;
  Lr=inl-inr;
  Rr=inl+inr;



  0[s]=Lr*c;
  1[s]=Rr*c;
  s+=2;
  
  
  //////////////////
  // Detect Phase //
  //////////////////
  As=abs(inl);
  Am=abs(inr);

  
  Am>=As ? Corr=1 : Corr=-1;     // Correlation     1.3
  Am==As && Am>0.001 ? Corr=0;   // Stabilizer      1.9
Indicor=Indicor-(Indicor-corr)*decay;

@gfx 479 434
  
  // Switch to main drawing context
  gfx_dest  = -1;
  gfx_mode  = 1; // additive
  gfx_clear = 0; // black
  
  initial == 0 ? (
  front=slider8;
  front.val=front;
  front.potVal(front.val);
  center=slider7;
  center.val=center;
  center.potVal(center.val);
  center.valOld=center;
  initial = 1;
  );
  
      mouseHold = mouse_cap & 1;
      ctrl = mouse_cap & 4;
      shift = mouse_cap & 8;
      mouseClick = mouseHold - lastCap;
      lastCap = mouseHold;
  
  
gfx_ext_flags == 1 ? (

  // Calculate the side length of a square centered in the window
  viewSize = gfx_h*0.8*0.5;//min(gfx_w, gfx_h) / 2;
  
  // The distance a dot may be from center in any
  // direction to still appear inside a circle.
  viewScale = (viewSize * 0.70710681);
  
  // The absolute center point in the current window
  centerX = gfx_w * 0.5;
  centerY = gfx_h*0.8 * 0.5;
  
  drawHistory();
  drawIndicators();
  
  
  size = min(gfx_w,gfx_h);
  Sizi = Size*45/46/2;
  gx0=gfx_w/2;
  gx2=gx0-sizeh*1/45;
  sizeH = size/2;
  sizeQ=sizeH/2;
  size2Q=2*sizeQ;
  size3Q=3*sizeQ;
  x03=gx0-sizeh;
  shiftLed=(size>150)*15+(size<150)*4;
  step=0.004;
  
  ph=Indicor;

  
  
  
    ////////////
    // Led 1  //
    ////////////
    
  
    gfx_r=gfx_g=gfx_b=0.1; gfx_g=0; gfx_a=0.066;
    gfx_x=gx2-sizi; gfx_y=size-1;
    gfx_rectto(gfx_x+size+11,gfx_y-size*0.06); //Hintergrund
    
    gfx_r=(1-PH)*0.7; gfx_g=(PH+1)*0.7; gfx_b=2*ph-1; gfx_a=1;
    gfx_r=0.4;
    gfx_g=0.8;
  Phx = (ph*gfx_w/2);
  phy= 7*gfx_h/8;
  gfx_x=phx-1+(gfx_w/2);gfx_y=phy;
    gfx_b=1; gfx_a=1; //gfx_x=gx2+(ph)*sizi; gfx_y=size-1;
    //gfx_rectto(gfx_x+size*0.033,gfx_y-size*0.06);
    PH < 0 ? (gfx_r = 1; gfx_g=0.3; gfx_b=0.3);
  gfx_rectto(gfx_x +2,gfx_y+20);
  
  
  
  
  
  
):( /// GFX EXT FLAGS  
  gfx_w=479;gfx_h=434;
  // Calculate the side length of a square centered in the window
  viewSize = 125;//min(gfx_w, gfx_h) / 2;
  
  // The distance a dot may be from center in any
  // direction to still appear inside a circle.
  viewScale = (viewSize * 0.70710681);
  
  // The absolute center point in the current window
  centerX = 165;//gfx_w * 0.5;
  centerY = 135;//gfx_h * 0.5;
  
  drawHistory();
  
  size = min(gfx_w,gfx_h);
  Sizi = Size*45/46/2;
  gx0=gfx_w/2;
  gx2=gx0-sizeh*1/45;
  sizeH = size/2;
  sizeQ=sizeH/2;
  size2Q=2*sizeQ;
  size3Q=3*sizeQ;
  x03=gx0-sizeh;
  shiftLed=(size>150)*15+(size<150)*4;
  step=0.004;
  
  ph=Indicor;
  
  
  ////////////
  // Led 1  //
  ////////////
  

  gfx_r=gfx_g=gfx_b=0.1; gfx_g=0; gfx_a=0.066;
  gfx_x=gx2-sizi; gfx_y=size-1;
  gfx_rectto(gfx_x+size+11,gfx_y-size*0.06); //Hintergrund
  
  gfx_r=(1-PH)*0.7; gfx_g=(PH+1)*0.7; gfx_b=2*ph-1; gfx_a=1;
  gfx_r=0.4;
  gfx_g=0.8;
Phx = (ph*110);
phy= 290;
gfx_x=phx+165;gfx_y=phy;
  gfx_b=1; gfx_a=1; //gfx_x=gx2+(ph)*sizi; gfx_y=size-1;
  //gfx_rectto(gfx_x+size*0.033,gfx_y-size*0.06);
  PH < 0 ? (gfx_r = 1; gfx_g=0.3; gfx_b=0.3);
gfx_rectto(gfx_x +5,gfx_y+20);













  drawIndicators();
  gfx_x=1;gfx_y=1;gfx_a=1;
  gfx_blit(0,1,0);
  
  
  center=slider7;
  center.val = slider7;
  center.potVal(center.val);
  
    front.knob();
    center.knob();

/********************************* Mouse Control ******************************/
mouseClick == 1 ? 
    (
      front.collision()   ? front.dragStart();   
      center.collision()  ? center.dragStart();  
      back.collision()    ? back.dragStart();   
    ):
mouseClick == -1  ? 
    (
      front.dragStop();
      center.dragStop();
      back.dragStop();
    );

mouse_wheel ? 
    (
      front.collision()   ? front.potWheel():
      center.collision()  ? center.potWheel():
      back.collision()    ? back.potWheel():
      mouse_wheel=0;
    );


front.dragging  ? front.potDrag();
center.dragging ? center.potDrag();
back.dragging   ? back.potDrag();

/******************************* Slider Knob Control **************************/
  
front!=front.val?
    (
      front=front.val;
      slider8=front;
      pot.potVal(front.val);
     ):
front!=slider8?
    (
      front=slider8;
      front.val=front;
      front.potVal(front.val);
      front.valOld=front;
      );
      
        
center!=center.val?
    (
      center=center.val;
      slider7=center;
      pot.potVal(center.val);
     ):
center!=slider7?
    (
      center=slider7;
      center.val=center;
      center.potVal(center.val);
      center.valOld=center;
    );  
    
); /// GFX EXT FLAGS