manglr2/secondapplet.pde

//contains the GUI (ie CP5) in the secondapplet. also contains 3 classes: shaderManager, Brick and Slider

PImage bin;


public class SecondApplet extends PApplet {
  ControlP5 cp5;
  shaderManager shaderManager = new shaderManager();
  ArrayList<Shader> shaderList = new ArrayList<Shader>();
  ArrayList<Brick> bricks = new ArrayList<Brick>();
  ArrayList<Slider> slider = new ArrayList<Slider>(); //brick 
  int binX, binY, binS;
  public void settings() {
    size(275, 120);
  }

  public void setup() {
    surface.setLocation(285, 240);
    List l = Arrays.asList(availableFx);
    cp5 = new ControlP5(this);
    cp5.addScrollableList("")
      .setPosition(10, height-110)
      .setSize(80, 100)
      .setBarHeight(0)
      .setItemHeight(20)
      .plugTo(this, "CP5_listActions")
      .addItems(l)
      .setType(ControlP5.LIST);
    cp5.addToggle("rec")
      .setPosition(100, height-50)
      .setSize(20, 20)
      .plugTo(this, "CP5_recordAction");

    binX = width-55;
    binY = height-85;
    binS = 40;
  }

  void CP5_recordAction() {
    recording = !recording;
  }

  int totalBrickHeight;
  public void draw() {
    background(68, 68, 68);
    image(bin, binX, binY, binS, binS);
    stroke(255);
    strokeWeight(1);
    line(0, height-120, width, height-120);
    totalBrickHeight = 0;  
    for (int i = 0; i < shaderList.size(); i++) { 
      bricks.get(i).update();
      bricks.get(i).display();
      bricks.get(i).y = totalBrickHeight;
      totalBrickHeight+= bricks.get(i).h;
    }
    if (pressedBrick != -1) {
      fill(255);
      noStroke();
      rect(mouseX, mouseY, 35, 15);
    }
  }


  void refreshSurface(int mode) {
    if (shaderList.size() > 0) {
      if (mode == 0) surface.setSize(width, height+bricks.get(shaderList.size()-1).h);
      else if (mode == 1) surface.setSize(width, height-bricks.get(pressedBrick).h);
    } else { 
      surface.setSize(width, 120);
    }

    cp5.setPosition(0, height-120);
    binY = height-85;
  }

  class shaderManager {

    void addShader(Shader shader) {
      shaderList.add(shader);
      shader.pos = shaderList.size()-1;
      bricks.add(new Brick(shaderList.size()-1, shaderList.get(shaderList.size()-1).params, shader.name));
      refreshSurface(0);
      println("Added " + shader + " to fxList at spot. List length: " + shaderList.size());
    }

    void swapShader(int pos1, int pos2) {
      //if (pos1 >= 0 && pos2 < shaderList.size()) {
      Collections.swap(shaderList, pos1, pos2);
      Collections.swap(bricks, pos1, pos2);
      shaderList.get(pos1).pos = pos1;
      shaderList.get(pos2).pos = pos2;
      bricks.get(pos1).setPos(pos1);
      bricks.get(pos2).setPos(pos2);
      for (int i = 0; i < bricks.size(); i++) {
        bricks.get(i).updateSliderPos();
      }
      //}
    }

    void moveShader(int pos1, int pos2) {
      Shader s = shaderList.remove(pos1);
      Brick b = bricks.remove(pos1);

      shaderList.add(pos2, s);
      bricks.add(pos2, b);
      for (int i = 0; i < bricks.size(); i++) {
        bricks.get(i).updateSliderPos();
      }
    }

    void removeShader(int pos) {
      if (pos >= 0 && shaderList.size() > pos) { 
        refreshSurface(1);
        shaderList.remove(pos);
        bricks.remove(pos);
        for (int i = shaderList.size()-1; i > -1; i--) {
          bricks.get(i).setPos(i); 
          bricks.get(i).updateSliderPos();
          shaderList.get(i).pos = i;
        }
      }
    }
    void applyShader() {
      for (int i = 0; i < shaderList.size(); i++) {
        shaderList.get(i).getValuesFromGUI();
        shaderList.get(i).apply();
        if (i > maxFx) break;
      }
    }
  }

  int pressedBrick = -1;
  class Brick {
    ArrayList<Slider> slider = new ArrayList<Slider>();
    ArrayList<Param> params = new ArrayList<Param>();
    boolean dragging, dragHovering, hovering, hoveringLineAbove, hoveringLineBelow;
    color brickBGcol;
    int pos;
    int h, y;
    String name;

    Brick(int pos_, ArrayList params_, String name_) {
      name = name_;
      pos = pos_;
      params = params_;
      y = totalBrickHeight;
      h = 20 + params.size() * 20;
      for (int i = 0; i < params.size(); i++) {
        slider.add(new Slider(10, 20+(20*i)+y, 230, 12, params.get(i).minValue, params.get(i).maxValue, params.get(i).name, params.get(i).type, params.get(i).osciModes)); //add possible waves to slider
      }
      println(totalBrickHeight + " " + h);
    }

    void setPos(int pos_) {
      pos = pos_;
    }

    void updateSliderPos() {
      y = 0;
      for (int i = 0; i < pos; i++) {
        y += bricks.get(i).h;
      }
      for (int i = 0; i < slider.size(); i++) {
        slider.get(i).y = 20+(20*i)+y;
      }
    }

    void exchangeSlider(int sliderNo, Param param) {
      slider.get(sliderNo).setMinMax(param.minValue, param.maxValue);
      slider.get(sliderNo).setMode(param.type);
      slider.get(sliderNo).setLabel(param.name);
    }


    void update() {
      boolean sliderHover = false;
      for (int i = 0; i < slider.size(); i++) {
        if (slider.get(i).hovering || slider.get(i).hovering_anim_btn)
          sliderHover = true;
      }

      if (mouseY > y-5 && mouseY < y+5 && pressedBrick != -1) {
        hoveringLineAbove = true;
      } else if (pos == bricks.size()-1 && mouseY > y+h-5 && mouseY < y+h+5 && pressedBrick != -1) {
        hoveringLineBelow = true;
      } else {
        hoveringLineBelow = false;
        hoveringLineAbove = false;
        if (mouseY > totalBrickHeight && mouseY < totalBrickHeight+h && !sliderHover) {
          hovering = true;
        } else {
          hovering = false;
        }
      }

      for (int i = 0; i < slider.size(); i++) {
        slider.get(i).update();
        params.get(i).value = slider.get(i).value;
      }
      brickBGcol = color(85, 85, 85);
    }

    void press() {
      pressedBrick = pos;
    }

    void display() {
      noStroke();
      if (dragging) brickBGcol = color(51, 51, 51);
      else if (dragHovering && !hoveringLineBelow && !hoveringLineAbove) brickBGcol= color (105, 105, 105);
      else brickBGcol = color(85, 85, 85);
      fill(brickBGcol);
      rect(0, totalBrickHeight, width, h);

      fill(255);
      text(name, 10, 10+totalBrickHeight, 10);

      for (int i = 0; i < slider.size(); i++) {
        slider.get(i).display();
      }

      stroke(150);
      strokeWeight(1);
      line(0, totalBrickHeight+h-1, width, totalBrickHeight+h-1);
      
      if(hoveringLineAbove){
        stroke(200);
        strokeWeight(5);
        line(0,y,width,y);
      }
      if(hoveringLineBelow){
        stroke(200);
        strokeWeight(5);
        line(0,y+h,width,y+h);
      }
    }
  }

  int pressedSlider = -1;

  //class Slider extends Brick{
  class Slider {
    int x, y, w, h, mode;
    int[] osciModes;
    float minVal, maxVal, value; //should be private but doesnt work lol
    boolean hovering, hovering_anim_btn, animated;
    String label;
    Oscillator osci;

    Slider(int x_, int y_, int w_, int h_, float minVal_, float maxVal_, String label_, int mode_, int[] osciModes_) {
      x = x_;
      y = y_;
      w = w_;
      h = h_;
      minVal = minVal_;
      maxVal = maxVal_;
      mode = mode_;
      label = label_ + (mode == INTVAL ? " (INT)" : " (FLOAT)");
      osciModes = osciModes_;

      osci = new Oscillator(int(random(5, 15)), osciModes);
      osci.amplitude(minVal, maxVal);

      animated = true;

      slider.add(this);
    }

    void setPosX(int x_) {
      x = x_;
    }

    void setMinMax(float min, float max) {
      float cval = map(value, minVal, maxVal, 0, 10000);
      minVal = min;
      maxVal = max;
      osci.amplitude(minVal, maxVal);
      setValue(map(cval, 0, 10000, minVal, maxVal));
    }
    void setLabel(String lab) {
      label = lab + (mode == INTVAL ? " (INT)" : " (FLOAT)");
    }
    void setMode(int mode_) {
      mode = mode_;
    }

    void press(int myId_) {
      pressedSlider = myId_;
      animated = false;
      setValue(map(mouseX, x, x+w, minVal, maxVal));
    }

    void setValue(float value_) {
      value = value_;
      value = constrain(value, minVal, maxVal);
      if (mode == INTVAL) value = int(round(value));
    }

    float getValue() {
      return(value);
    }

    void update() {



      osci.update();

      if (animated) {
        setValue(osci.value);
      }


      if (mouseX >= x && mouseX <= x+w && mouseY >= y && mouseY <= y+h) {
        hovering = true;
      } else {
        hovering = false;
      }

      if (mouseX >= x+w+5 && mouseX <= x+w+5+15 && mouseY >= y && mouseY <= y+h) {
        hovering_anim_btn = true;
      } else {
        hovering_anim_btn = false;
      }
    }

    void display() {

      stroke(255);
      strokeWeight(1);
      fill(100+(40*int(hovering)));
      rect(x, y, w, h);
      fill(185+(40*int(hovering)));
      rect(x, y, map(value, minVal, maxVal, 0, w), h);
      fill(255);
      text(label, x+5, y+7);

      if (animated) {
        fill(185+(40*int(hovering_anim_btn)));
      } else {
        fill(100+(40*int(hovering_anim_btn)));
      }
      rect(x+w+5, y, h, h);
    }
  }

  //CP5
  void CP5_listActions(int n) {
    if (shaderList.size() < maxFx) {
      switch(n) {
        case(0): 
        shaderManager.addShader(new ASDFPIXELSORT()); 
        break;
        case(1): 
        shaderManager.addShader(new DISTORTER()); 
        break;
        /*
        case(2): 
         shaderManager.addShader(new WAHWAH()); 
         break;
         case(3): 
         shaderManager.addShader(new AUECHO()); 
         break;
         case(4): 
         shaderManager.addShader(new PHASER()); 
         break;
         case(0): 
         shaderManager.addShader(new WZIP()); 
         break;
         case(0): 
         shaderManager.addShader(new DARKER()); 
         break;
         case(0): 
         shaderManager.addShader(new BRIGHTER()); 
         break;
         case(0): 
         shaderManager.addShader(new MOVE()); 
         break;
         case(0): 
         shaderManager.addShader(new SCALE()); 
         break;
         case(0): 
         shaderManager.addShader(new EPILEPSY()); 
         break;
         case(0): 
         shaderManager.addShader(new POSTERIZE()); 
         break;
         case(0): 
         shaderManager.addShader(new COPYZOOM()); 
         break;
         case(0): 
         shaderManager.addShader(new DUAL()); 
         break;
         case(0): 
         shaderManager.addShader(new SCANKER()); 
         break;
         case(0): 
         shaderManager.addShader(new PIXELSORT()); 
         break;
         case(0): 
         shaderManager.addShader(new HSB()); 
         break;
         case(0): 
         shaderManager.addShader(new ECHO()); 
         break;
         case(0): 
         shaderManager.addShader(new SUBTLESORT()); 
         break;
         case(0): 
         shaderManager.addShader(new BLACKWHITE()); 
         break;
         case(0): 
         shaderManager.addShader(new DRAWGENERATIVE()); 
         break;
         case(0): 
         shaderManager.addShader(new DRAWSTROKES()); 
         break;
         case(0): 
         shaderManager.addShader(new FM()); 
         break;
         case(0): 
         shaderManager.addShader(new GRAUZONE()); 
         break;
         case(0): 
         shaderManager.addShader(new SLITSCAN()); 
         break;
         */
      default:
        break;
      }
    }
  }

  void mousePressed() {
    for (int i = slider.size()-1; i >= 0; i--) {
      Slider s = slider.get(i);
      if (s.hovering) s.press(i);
      if (s.hovering_anim_btn) s.animated = !s.animated;
    }
    for (int i = bricks.size()-1; i >= 0; i--) {
      if (bricks.get(i).hovering) {
        bricks.get(i).press();
      }
    }
  }
  void mouseDragged() {
    if (pressedSlider != -1) {
      Slider s = slider.get(pressedSlider);
      s.setValue(map(mouseX, s.x, s.x+s.w, s.minVal, s.maxVal));
    }
    if (pressedBrick != -1) {
      bricks.get(pressedBrick).dragging = true;

      for (int i = 0; i < bricks.size(); i++) {
        if (pressedBrick != i && bricks.get(i).hovering) {
          bricks.get(i).dragHovering = true;
        } else {
          bricks.get(i).dragHovering = false;
        }
      }
    }
  }

  void mouseReleased() {
    if (pressedBrick != -1) {
      bricks.get(pressedBrick).dragging = false;
      
      for (int i = 0; i < bricks.size(); i++) {
        bricks.get(i).dragHovering = false;
        if (pressedBrick != i && bricks.get(i).hovering && !bricks.get(i).hoveringLineAbove && !bricks.get(i).hoveringLineBelow) {
          shaderManager.swapShader(pressedBrick, i);
        }
        
        
        if(pressedBrick != i && bricks.get(i).hoveringLineAbove){
          shaderManager.moveShader(pressedBrick,i);
        }
        if(pressedBrick != i && bricks.get(i).hoveringLineBelow){
          shaderManager.moveShader(pressedBrick,bricks.size()-1); //move to last
        }
        
        
        
        
      }
      
      if (mouseX > binX && mouseX < binX+binS && mouseY > binY && mouseY < binY+binS) {
        println("removing");
        shaderManager.removeShader(pressedBrick);
      }
    }
    pressedSlider = -1;
    pressedBrick = -1;
  }
}