Click to begin; When, Then, Now

​

​

//  LUCY BARKER u 3097464

//  Introduction to Digital Design, u 8196, Sem 1, Uni of Canberra 2013, MA Digital Design 103JA

//  This code has been adapted from a a project in Mitchell Whitelaws class on Swarm properties.

//  Swarm project

//  Haiku

​

//  PROJECTION FILE - interactive performance model

​

​

​

PVector mouse;

int bg_colour=0;

int motion=1;

int mousemode=0;

int facetcol = 1;

​

int thresh=210;

int mousethresh=150;

​

int avoid_distance = 80;

float avoid_strength = 0.6;

​

int cohere_distance = 130;

float cohere_strength = 0.07;

​

int align_distance = 60;

float align_strength = 0.03;

​

float mouse_attract = 0.009;

​

float maxvel = 1.8;

​

​

ArrayList swarm = new ArrayList(); // create a new ArrayList called 'swarm'

​

// set up poster proportions

​

void setup() {

  size(1200, 800);

  //size(displayWidth,displayHeight); // good for time of projection

  colorMode(HSB);

}

​

// begin draw functions

void draw() {

​

  if (bg_colour==0) {

    background(0);

  }

  else {

    background(255);

  }

​

  for (int i=0; i<swarm.size(); i++) { // for the entire array this perform the following functions

    Dot myDot = (Dot) swarm.get(i); // first remove an object from the list and call it freshDot

    myDot.render(); 

    if (motion==1) { 

      myDot.move();

    }

    myDot.cohere();

    myDot.align();

    myDot.avoid();

    if (mousemode==1) {//this function will cause the objects to move towards the mouse. Switched on with TAB key

      myDot.toMouse();

    }

    myDot.bounce();//make my object bounce off the sides if it hits the edges of the page

  }

}

​

//mouse activates animation by creatin objects

​

void mousePressed() {

​

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

    PVector newpos = new PVector(mouseX, mouseY);

    Dot myDot = new Dot( newpos, 1 ); 

    swarm.add(myDot);

    println(swarm.size());

  }

}

​

//INTERACTIVE KEY CONTROLS

​

void keyPressed() {

​

  if (key=='5') {// add 5 colour vertex

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

      PVector newpos = new PVector(mouseX, mouseY);

      Dot myDot = new Dot( newpos, 1 ); 

      myDot.col=color(random(255), random(180, 230), 255, 90);

      swarm.add(myDot);

    }

  }

​

  if (key == ' ') { //freeze movement

    if (motion == 1) {

      motion=0;

    } 

    else if (motion == 0) { 

      motion=1;

    }

  }

​

  if (keyCode == SHIFT) {//delete objects around mouse within 'mouse thresh'range

    for (int i=0; i<swarm.size(); i++) { // loop through the ArrayList created on the setup() tab, to store my Dot objects

      Dot removeDot=(Dot)swarm.get(i);

      mouse =new PVector (mouseX, mouseY);

      float distance = removeDot.pos.dist(mouse);

      if (distance < mousethresh) {

        swarm.remove(removeDot);

      }

    }

  }

  if (key == '1') {// these 2 keys will change the area that the SHIFT key effects when deleteing objects

    mousethresh-=10;

  }

  if (key == '2') {

    mousethresh+=10;

  }

  if (key == '3') {

    println(mousethresh);

  }

  if (key == 'd') {//delete last 5 objects added

    println("deletinglast");

    println(swarm.size());

    // Dot removeDot=(Dot)swarm.get(0);

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

      Dot removeDot=(Dot)swarm.get(swarm.size()-1);

      swarm.remove(removeDot);

      println(swarm.size());

    }

  }

​

  if (key == 'f') {//delete first 5 objects added

    println("deletingfirst");

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

      Dot removeDot=(Dot)swarm.get(0);

      swarm.remove(removeDot);

      println(swarm.size());

    }

  }

​

  if (key == '>') {//increase thresh hold & therefore size of triangles

    thresh=thresh+10;

    println("increasethresh");

    println(thresh);

  }

  if (key == '<') {

    thresh=thresh-10;

    println("decreasethresh");

    println(thresh);

  }

​

  if (key == 'm') { // switch to preferred mode

    thresh=210;

​

    avoid_distance = 80;

    avoid_strength = 0.6;

​

    cohere_distance = 130;

    cohere_strength = 0.07;

​

    align_distance = 60;

    align_strength = 0.03;

​

    mouse_attract = 0.009;

​

    maxvel = 1.8;

    println(swarm.size());

  }

​

  if (key == 'n') {// swith to prefferd state

    swarm.clear(); // empty the list

    makeDots(30); // make 30 new agents

    thresh=210;

​

    avoid_distance = 80;

    avoid_strength = 0.6;

​

    cohere_distance = 130;

    cohere_strength = 0.07;

​

    align_distance = 60;

    align_strength = 0.03;

​

    mouse_attract = 0.009;

​

    maxvel = 1.8;

  }

​

  if (key == 'c') {//clear the screen

​

    swarm.clear();

  }

​

  if (key == 'h') {//toggle between coloured vertex and white

    if (facetcol == 1) {//if white 

      for (int i=0; i<swarm.size(); i++) { //run through list 

        Dot myDot = (Dot) swarm.get(i);

        myDot.col=color(random(255), random(180, 210), 255, 90);//make coloured

      }

      facetcol = 0;//and then

    } 

    else if (facetcol == 0) { 

      for (int i=0; i<swarm.size(); i++) { 

        Dot myDot = (Dot) swarm.get(i);

        myDot.col=color(255, 110);

      }

      facetcol=1;

    }

  }

​

  if (key == 'b') {//change background coloour to white

    if (bg_colour == 0) {

      background(255);

      bg_colour=1;

    }

    else if (bg_colour==1) {

      bg_colour=0;

    }

  }

​

  if (key == CODED) {

    if (keyCode == UP) {// increase velocity of swarm

      println("faster");

      maxvel+=0.2;

      println(maxvel);

    }

  } 

  if (keyCode == DOWN) { // decrease velocity of swarm

    maxvel-=0.2;

    println("slower");

    println(maxvel);

  }

​

  if (keyCode == RIGHT) {// increase avoidance of objects

    avoid_strength+=0.1;

    avoid_distance+=10;

    println(avoid_strength);

    println(avoid_distance);

​

    println(avoid_strength);

  }

  if (keyCode == LEFT) {// decrease avoidance of objects

    avoid_strength-=0.1;

    avoid_distance-=10;

    println(avoid_strength);

    println(avoid_distance);

  }

​

  if (key == ']') {// increase coherence of objects

    cohere_distance += 10;

    cohere_strength += 0.01;

  }

​

  if (key == '[') {// decrease coherence of objects

    cohere_distance -= 10;

    cohere_strength -= 0.01;

  }

​

  if (key=='l') { // increase alignment of objects - infact not very useful

    align_distance += 10;

    align_strength += 0.01;

  }

  if (key=='k') {// decrease alignment of objects - infact not very useful

    align_distance -= 10;

    align_strength -= 0.01;

  }

​

  if (keyCode == TAB) {// change mode so objects are atttracted to mouse

    if (mousemode == 1) {

      mousemode=0;

    } 

    else if (mousemode == 0) { 

      mousemode=1;

    }

  }

  if (key=='w') {   // strength of attraction to mouse increased

    mouse_attract += 0.001;

  }

  if (key=='q') {   // strength of attraction to mouse decreased

    mouse_attract -= 0.001;

  }

​

}

​

​

void makeDots( int numdots ) {

  for (int i=0; i<numdots; i++) {// each time the mouse is pressed it will create 20 iterations or 'instnaces' of our object.  For more detailed description of how this works refer to a previous sketch.

    //PVector newpos = new PVector(mouseX,mouseY);//this code which is turned off would cause the 20objects to appear at the location the mouse is pressed.

    PVector newpos = new PVector(random(width), random(height));// here we declare a new PVector 'newpos' which has it's position anyway on the screen.

    Dot myDot = new Dot( newpos, 1 ); // here we refer back to our object 'constructor' on the other tab. With the click of the mouse our new object is assigned a random position and a diamneter of 3. The info is then stored in myDot.

    swarm.add(myDot); // here we add the data assigned to 'myDot' to our ArrayList 'swarm'

  }

}

​

class Dot { // here I am creating a CUSTOM CLASS, signified with a capital letter.

  // a class in composed of both data and functions which is represented as OBJECTS.

​

  // I now go on to create a template for my OBJECT.

  //It will describe both the state(data) and the behaviour(function) of the object.  

  //We can use this model to represent real world objects

​

  float diam; // declare a variable to describe the size of the dot, 'it's diameter'

  PVector pos; // declare 'pos'the position of a Dot (as a PVector)

PVector vel; // declare a variable 'vel' the velocity of a Dot (as a PVector)

  PVector acc; // declare a variable 'acc' the acceleration of a Dot (as a PVector)

  color col;//declare 'col' a variable for the colour of a Dot

​

​

​

​

​

  Dot( PVector _pos, float _diam ) { // constructor, belongs to the Class structure and functions to make a new object from the class 'Dot'

    // this function, with 2 arguments, runs once when the object is made

    // this is our personal object setup function

    pos = _pos; // assign our internal pos

    diam = _diam; // assign our internal diam

    vel = new PVector(random(-1, 1), random(-1, 1)); // initial velocity of dot will vary.

    col =  color(255, 110);

    acc = new PVector(0, 0);// starts with no acceleration.  If this were to be representative of an object in the real world,

    // such as a ball, we would add gravity in here

  }

​

​

  void render() {

​

    beginShape(TRIANGLE_FAN);

    noStroke();

    fill(col);

    vertex(pos.x, pos.y);

​

​

    for (int i=0; i<swarm.size(); i++) { // loop through the ArrayList created on the setup() tab, to store my Dot objects

      Dot neighbour = (Dot) swarm.get(i);

​

      float distance = pos.dist( neighbour.pos );

      if (distance < thresh) {

        vertex(neighbour.pos.x, neighbour.pos.y);

      }

    }

    vertex(pos.x, pos.y);

    endShape(TRIANGLE_FAN);

  }

​

​

  void move() { // our 'move' function to animate the object

​

    vel.add(acc); // update velocity vector by adding the current acceleration vector

    vel.limit(maxvel); // limit the velocity to a maximum value specified in our variable declared above.

    pos.add(vel); // update our position to create movement by adding the current velocity vector

    acc.mult(0); // then reset acceleration back to zero

  }

​

  void bounce() { // make a function that makes the Dots bounce back when they hit the edge of the page

    if (pos.x < 0) { // left edge 

      vel.x = vel.x * -1; // reverse the x velocity

    }

​

    if (pos.x > width) { // if our object Dot hits theright edge 

      vel.x = vel.x * -1; // reverse the x velocity

    }

​

    if (pos.y < 0) { // if our object Dot hits the top edge 

      vel.y=vel.y * -1; // reverse the y velocity

    }

​

    if (pos.y > height) { // bottom edge 

      vel.y = vel.y * -1; // reverse the y velocity

    }

  }

​

​

  void toMouse() {//this function we make causes the lines to 'chase' the mouse

    PVector m = new PVector(mouseX, mouseY);// mouse position signified by'm'

    PVector mpull = PVector.sub(m, pos);//velocity is the difference between these 2 points over time

    mpull.normalize();//make this velocity, mpull, a unit vector by setting it's length to 1

    mpull.mult(mouse_attract);// alter the speed the object moves towards the mouse by the variable factor 'mouse_attract' we created earlier

    acc.add(mpull);//acceleration, change of velocity over time becomes the same as the mouse_factor.

  }

​

​

​

  void avoid() { // this function we are about to create means the Dots or lines will avoid colliding.

    for (int i=0; i<swarm.size(); i++) { // loop through the ArrayList created on the setup() tab, to store my Dot objects

      Dot neighbour = (Dot) swarm.get(i); // get one out of the ArrayList and declare it 'neighbour'

      float distance = pos.dist( neighbour.pos ); // distance

      if (distance < avoid_distance) { // if the distance between the concecutive points is less than the avoid distance specfied at the begining then we create a 'push'to move them apart

        PVector push = PVector.sub(pos, neighbour.pos); // the 'push' or the velocity with which they move apart in calculated by the diff of the 2 positions

        push.normalize(); // scale the velocity to 1

        push.mult(avoid_strength); // control this velocity by multiplying it by the 'avoid strength'specified at the beginning.

        acc.add(push); // add this push to the global acceleration

      }

    }

  }

​

  void cohere() { // stick together

    // find the middle of my neighbour Dots 

    // and move towards that location 

    PVector mid_pos = new PVector(); // declare a new variable 'mid_pos' to store the average position of my neighbours

    int neighbour_count = 0; // declare a variable 'neighbour count' and set it at zero.

​

    for (int i=0; i<swarm.size(); i++) { // for the entire ArrayList of indefinite size

      Dot neighbour = (Dot) swarm.get(i); // get an object out and store it's info in 'neighbour'

      float distance = pos.dist( neighbour.pos ); // declare a variable 'distance'and set it as equal to the distance between our object and it's neighbour.

      if (distance < cohere_distance) { // if this distance is less than our variable set at the begining or in other words 'they are within a certain dist of each other'

        mid_pos.add(neighbour.pos); // then add my neighbours position to the average position of all our neighbours

        neighbour_count++; // now we need to add 1 to the neighbour count

      }

    }

    mid_pos.div( neighbour_count ); // now we need to divide the new mid_pos by the new neighbour count

    PVector pull = PVector.sub(mid_pos, pos); //  to make a pull velocity we need to subtract subtract the 2 positions, the mid position of all the neighbours, and the position of our current object.

    pull.normalize(); // scale the velocity to 1

    pull.mult(cohere_strength); // multiply the pull velocity by our variable 'cohere_strength'

    acc.add(pull); // add this pull to the global acceleration

  }

​

  void align() { // fly in the same direction and match speed ie match velocity as this pVector holds speed and direction info

    // find the average velocity of my neighbours

    // then head in that direction

    PVector ave_vel = new PVector(); // to store the average velocity

    int neighbour_count = 0; // neighbour count variable set at 0

​

      for (int i=0; i<swarm.size(); i++) { // loop through the list

      Dot neighbour = (Dot) swarm.get(i); // get an object out and store it's info in 'neighbour'

      float distance = pos.dist( neighbour.pos ); // declare a variable 'distance'and set it as equal to the distance between our object and it's neighbour.

      if (distance < align_distance) { // if this distance is less than our variable set at the begining or in other words 'they are within a certain dist of each other'

        ave_vel.add(neighbour.vel); // add my neighbours velocity to the average velocity

        neighbour_count++; // add 1 to the neighbour count

      }

    }

    ave_vel.div( neighbour_count ); // now to establish the new ave velocity divide by the neighbour count

    // make a pull by subtracting the positions

    ave_vel.normalize(); // first scale the velocity to 1

    ave_vel.mult(align_strength); // now multiply it by our variable 'align_strength'

    acc.add(ave_vel); // add this pull to the global acceleration

  }

}

​

​

​