Initial Commit

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Clock/Clock.pde

@@ -0,0 +1,62 @@
+/**
+ * Clock. 
+ * 
+ * The current time can be read with the second(), minute(), 
+ * and hour() functions. In this example, sin() and cos() values
+ * are used to set the position of the hands.
+ */
+
+int cx, cy;
+float secondsRadius;
+float minutesRadius;
+float hoursRadius;
+float clockDiameter;
+
+void setup() {
+  size(640, 360);
+  stroke(255);
+  
+  int radius = min(width, height) / 2;
+  secondsRadius = radius * 0.72;
+  minutesRadius = radius * 0.60;
+  hoursRadius = radius * 0.50;
+  clockDiameter = radius * 1.8;
+  
+  cx = width / 2;
+  cy = height / 2;
+}
+
+void draw() {
+  background(0);
+  
+  // Draw the clock background
+  fill(80);
+  noStroke();
+  ellipse(cx, cy, clockDiameter, clockDiameter);
+  
+  // Angles for sin() and cos() start at 3 o'clock;
+  // subtract HALF_PI to make them start at the top
+  float s = map(second(), 0, 60, 0, TWO_PI) - HALF_PI;
+  float m = map(minute() + norm(second(), 0, 60), 0, 60, 0, TWO_PI) - HALF_PI; 
+  float h = map(hour() + norm(minute(), 0, 60), 0, 24, 0, TWO_PI * 2) - HALF_PI;
+  
+  // Draw the hands of the clock
+  stroke(255);
+  strokeWeight(1);
+  line(cx, cy, cx + cos(s) * secondsRadius, cy + sin(s) * secondsRadius);
+  strokeWeight(2);
+  line(cx, cy, cx + cos(m) * minutesRadius, cy + sin(m) * minutesRadius);
+  strokeWeight(4);
+  line(cx, cy, cx + cos(h) * hoursRadius, cy + sin(h) * hoursRadius);
+  
+  // Draw the minute ticks
+  strokeWeight(2);
+  beginShape(POINTS);
+  for (int a = 0; a < 360; a+=6) {
+    float angle = radians(a);
+    float x = cx + cos(angle) * secondsRadius;
+    float y = cy + sin(angle) * secondsRadius;
+    vertex(x, y);
+  }
+  endShape();
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Constrain/Constrain.pde

@@ -0,0 +1,38 @@
+/**
+ * Constrain. 
+ * 
+ * Move the mouse across the screen to move the circle. 
+ * The program constrains the circle to its box. 
+ */
+ 
+float mx;
+float my;
+float easing = 0.05;
+int radius = 24;
+int edge = 100;
+int inner = edge + radius;
+
+void setup() {
+  size(640, 360);
+  noStroke(); 
+  ellipseMode(RADIUS);
+  rectMode(CORNERS);
+}
+
+void draw() { 
+  background(51);
+  
+  if (abs(mouseX - mx) > 0.1) {
+    mx = mx + (mouseX - mx) * easing;
+  }
+  if (abs(mouseY - my) > 0.1) {
+    my = my + (mouseY- my) * easing;
+  }
+  
+  mx = constrain(mx, inner, width - inner);
+  my = constrain(my, inner, height - inner);
+  fill(76);
+  rect(edge, edge, width-edge, height-edge);
+  fill(255);  
+  ellipse(mx, my, radius, radius);
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Easing/Easing.pde

@@ -0,0 +1,33 @@
+/**
+ * Easing. 
+ * 
+ * Move the mouse across the screen and the symbol will follow.  
+ * Between drawing each frame of the animation, the program
+ * calculates the difference between the position of the 
+ * symbol and the cursor. If the distance is larger than
+ * 1 pixel, the symbol moves part of the distance (0.05) from its
+ * current position toward the cursor. 
+ */
+ 
+float x;
+float y;
+float easing = 0.05;
+
+void setup() {
+  size(640, 360); 
+  noStroke();  
+}
+
+void draw() { 
+  background(51);
+  
+  float targetX = mouseX;
+  float dx = targetX - x;
+  x += dx * easing;
+  
+  float targetY = mouseY;
+  float dy = targetY - y;
+  y += dy * easing;
+  
+  ellipse(x, y, 66, 66);
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Keyboard/Keyboard.pde

@@ -0,0 +1,38 @@
+/**
+ * Keyboard. 
+ * 
+ * Click on the image to give it focus and press the letter keys 
+ * to create forms in time and space. Each key has a unique identifying 
+ * number. These numbers can be used to position shapes in space. 
+ */
+
+int rectWidth;
+   
+void setup() {
+  size(640, 360);
+  noStroke();
+  background(0);
+  rectWidth = width/4;
+}
+
+void draw() { 
+  // keep draw() here to continue looping while waiting for keys
+}
+
+void keyPressed() {
+  int keyIndex = -1;
+  if (key >= 'A' && key <= 'Z') {
+    keyIndex = key - 'A';
+  } else if (key >= 'a' && key <= 'z') {
+    keyIndex = key - 'a';
+  }
+  if (keyIndex == -1) {
+    // If it's not a letter key, clear the screen
+    background(0);
+  } else { 
+    // It's a letter key, fill a rectangle
+    fill(millis() % 255);
+    float x = map(keyIndex, 0, 25, 0, width - rectWidth);
+    rect(x, 0, rectWidth, height);
+  }
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/KeyboardFunctions/KeyboardFunctions.pde

@@ -0,0 +1,87 @@
+/**
+ * Keyboard Functions. 
+ * Modified from code by Martin. 
+ * Original 'Color Typewriter' concept by John Maeda. 
+ * 
+ * Click on the window to give it focus and press the letter keys to type colors. 
+ * The keyboard function keyPressed() is called whenever
+ * a key is pressed. keyReleased() is another keyboard
+ * function that is called when a key is released.
+ */
+ 
+int maxHeight = 40;
+int minHeight = 20;
+int letterHeight = maxHeight; // Height of the letters
+int letterWidth = 20;          // Width of the letter
+
+int x = -letterWidth;          // X position of the letters
+int y = 0;                      // Y position of the letters
+
+boolean newletter;              
+
+int numChars = 26;      // There are 26 characters in the alphabet
+color[] colors = new color[numChars];
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  colorMode(HSB, numChars);
+  background(numChars/2);
+  // Set a hue value for each key
+  for(int i = 0; i < numChars; i++) {
+    colors[i] = color(i, numChars, numChars);    
+  }
+}
+
+void draw() {
+  if(newletter == true) {
+    // Draw the "letter"
+    int y_pos;
+    if (letterHeight == maxHeight) {
+      y_pos = y;
+      rect( x, y_pos, letterWidth, letterHeight );
+    } else {
+      y_pos = y + minHeight;
+      rect( x, y_pos, letterWidth, letterHeight );
+      fill(numChars/2);
+      rect( x, y_pos-minHeight, letterWidth, letterHeight );
+    }
+    newletter = false;
+  }
+}
+
+void keyPressed()
+{
+  // If the key is between 'A'(65) to 'Z' and 'a' to 'z'(122)
+  if((key >= 'A' && key <= 'Z') || (key >= 'a' && key <= 'z')) {
+    int keyIndex;
+    if(key <= 'Z') {
+      keyIndex = key-'A';
+      letterHeight = maxHeight;
+      fill(colors[keyIndex]);
+    } else {
+      keyIndex = key-'a';
+      letterHeight = minHeight;
+      fill(colors[keyIndex]);
+    }
+  } else {
+    fill(0);
+    letterHeight = 10;
+  }
+
+  newletter = true;
+
+  // Update the "letter" position
+  x = ( x + letterWidth ); 
+
+  // Wrap horizontally
+  if (x > width - letterWidth) {
+    x = 0;
+    y+= maxHeight;
+  }
+
+  // Wrap vertically
+  if( y > height - letterHeight) {
+    y = 0;      // reset y to 0
+  }
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Milliseconds/Milliseconds.pde

@@ -0,0 +1,24 @@
+/**
+ * Milliseconds. 
+ * 
+ * A millisecond is 1/1000 of a second. 
+ * Processing keeps track of the number of milliseconds a program has run.
+ * By modifying this number with the modulo(%) operator, 
+ * different patterns in time are created.  
+ */
+ 
+float scale;
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  scale = width/20;
+}
+
+void draw() { 
+  for (int i = 0; i < scale; i++) {
+    colorMode(RGB, (i+1) * scale * 10);
+    fill(millis()%((i+1) * scale * 10));
+    rect(i*scale, 0, scale, height);
+  }
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Mouse1D/Mouse1D.pde

@@ -0,0 +1,27 @@
+/**
+ * Mouse 1D. 
+ * 
+ * Move the mouse left and right to shift the balance. 
+ * The "mouseX" variable is used to control both the 
+ * size and color of the rectangles. 
+ */
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  colorMode(RGB, height, height, height);
+  rectMode(CENTER);
+}
+
+void draw() {
+  background(0.0);
+
+  float r1 = map(mouseX, 0, width, 0, height);
+  float r2 = height-r1;
+  
+  fill(r1);
+  rect(width/2 + r1/2, height/2, r1, r1);
+  
+  fill(r2);
+  rect(width/2 - r2/2, height/2, r2, r2);
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/Mouse2D/Mouse2D.pde

@@ -0,0 +1,21 @@
+/**
+ * Mouse 2D. 
+ * 
+ * Moving the mouse changes the position and size of each box. 
+ */
+ 
+void setup() {
+  size(640, 360); 
+  noStroke();
+  rectMode(CENTER);
+}
+
+void draw() {
+  background(51); 
+  fill(255, 204);
+  rect(mouseX, height/2, mouseY/2+10, mouseY/2+10);
+  fill(255, 204);
+  int inverseX = width-mouseX;
+  int inverseY = height-mouseY;
+  rect(inverseX, height/2, (inverseY/2)+10, (inverseY/2)+10);
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/MouseFunctions/MouseFunctions.pde

@@ -0,0 +1,64 @@
+/**
+ * Mouse Functions. 
+ * 
+ * Click on the box and drag it across the screen. 
+ */
+ 
+float bx;
+float by;
+int boxSize = 75;
+boolean overBox = false;
+boolean locked = false;
+float xOffset = 0.0; 
+float yOffset = 0.0; 
+
+void setup() {
+  size(640, 360);
+  bx = width/2.0;
+  by = height/2.0;
+  rectMode(RADIUS);  
+}
+
+void draw() { 
+  background(0);
+  
+  // Test if the cursor is over the box 
+  if (mouseX > bx-boxSize && mouseX < bx+boxSize && 
+      mouseY > by-boxSize && mouseY < by+boxSize) {
+    overBox = true;  
+    if(!locked) { 
+      stroke(255); 
+      fill(153);
+    } 
+  } else {
+    stroke(153);
+    fill(153);
+    overBox = false;
+  }
+  
+  // Draw the box
+  rect(bx, by, boxSize, boxSize);
+}
+
+void mousePressed() {
+  if(overBox) { 
+    locked = true; 
+    fill(255, 255, 255);
+  } else {
+    locked = false;
+  }
+  xOffset = mouseX-bx; 
+  yOffset = mouseY-by; 
+
+}
+
+void mouseDragged() {
+  if(locked) {
+    bx = mouseX-xOffset; 
+    by = mouseY-yOffset; 
+  }
+}
+
+void mouseReleased() {
+  locked = false;
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/MousePress/MousePress.pde

@@ -0,0 +1,24 @@
+/**
+ * Mouse Press. 
+ * 
+ * Move the mouse to position the shape. 
+ * Press the mouse button to invert the color. 
+ */
+
+
+void setup() {
+  size(640, 360);
+  noSmooth();
+  fill(126);
+  background(102);
+}
+
+void draw() {
+  if (mousePressed) {
+    stroke(255);
+  } else {
+    stroke(0);
+  }
+  line(mouseX-66, mouseY, mouseX+66, mouseY);
+  line(mouseX, mouseY-66, mouseX, mouseY+66); 
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/MouseSignals/MouseSignals.pde

@@ -0,0 +1,55 @@
+/**
+ * Mouse Signals. 
+ * 
+ * Move and click the mouse to generate signals. 
+ * The top row is the signal from "mouseX", 
+ * the middle row is the signal from "mouseY",
+ * and the bottom row is the signal from "mousePressed". 
+ */
+ 
+int[] xvals;
+int[] yvals;
+int[] bvals;
+
+void setup() 
+{
+  size(640, 360);
+  noSmooth();
+  xvals = new int[width];
+  yvals = new int[width];
+  bvals = new int[width];
+}
+
+int arrayindex = 0;
+
+void draw()
+{
+  background(102);
+  
+  for(int i = 1; i < width; i++) { 
+    xvals[i-1] = xvals[i]; 
+    yvals[i-1] = yvals[i];
+    bvals[i-1] = bvals[i];
+  } 
+  // Add the new values to the end of the array 
+  xvals[width-1] = mouseX; 
+  yvals[width-1] = mouseY;
+  if(mousePressed) {
+    bvals[width-1] = 0;
+  } else {
+    bvals[width-1] = 255;
+  }
+  
+  fill(255);
+  noStroke();
+  rect(0, height/3, width, height/3+1);
+
+  for(int i=1; i<width; i++) {
+    stroke(255);
+    point(i, xvals[i]/3);
+    stroke(0);
+    point(i, height/3+yvals[i]/3);
+    stroke(255);
+    line(i, 2*height/3+bvals[i]/3, i, (2*height/3+bvals[i-1]/3));
+  }
+}

Java/Processing/processing-3.3.6/modes/java/examples/Basics/Input/StoringInput/StoringInput.pde

@@ -0,0 +1,35 @@
+/**
+ * Storing Input. 
+ * 
+ * Move the mouse across the screen to change the position
+ * of the circles. The positions of the mouse are recorded
+ * into an array and played back every frame. Between each
+ * frame, the newest value are added to the end of each array
+ * and the oldest value is deleted. 
+ */
+ 
+int num = 60;
+float mx[] = new float[num];
+float my[] = new float[num];
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  fill(255, 153); 
+}
+
+void draw() {
+  background(51); 
+  
+  // Cycle through the array, using a different entry on each frame. 
+  // Using modulo (%) like this is faster than moving all the values over.
+  int which = frameCount % num;
+  mx[which] = mouseX;
+  my[which] = mouseY;
+  
+  for (int i = 0; i < num; i++) {
+    // which+1 is the smallest (the oldest in the array)
+    int index = (which+1 + i) % num;
+    ellipse(mx[index], my[index], i, i);
+  }
+}