First commit, old Processing 3 examples without changes

Author: REAS

.gitignore

@@ -0,0 +1,2 @@
+# Ignore this stuff
+.DS_Store

Basics/Arrays/Array/Array.pde

@@ -0,0 +1,50 @@
+/**
+ * Array. 
+ * 
+ * An array is a list of data. Each piece of data in an array 
+ * is identified by an index number representing its position in 
+ * the array. Arrays are zero based, which means that the first 
+ * element in the array is [0], the second element is [1], and so on. 
+ * In this example, an array named "coswave" is created and
+ * filled with the cosine values. This data is displayed three 
+ * separate ways on the screen.  
+ */
+
+
+float[] coswave; 
+
+void setup() {
+  size(640, 360);
+  coswave = new float[width];
+  for (int i = 0; i < width; i++) {
+    float amount = map(i, 0, width, 0, PI);
+    coswave[i] = abs(cos(amount));
+  }
+  background(255);
+  noLoop();
+}
+
+void draw() {
+
+  int y1 = 0;
+  int y2 = height/3;
+  for (int i = 0; i < width; i++) {
+    stroke(coswave[i]*255);
+    line(i, y1, i, y2);
+  }
+
+  y1 = y2;
+  y2 = y1 + y1;
+  for (int i = 0; i < width; i++) {
+    stroke(coswave[i]*255 / 4);
+    line(i, y1, i, y2);
+  }
+  
+  y1 = y2;
+  y2 = height;
+  for (int i = 0; i < width; i++) {
+    stroke(255 - coswave[i]*255);
+    line(i, y1, i, y2);
+  }
+  
+}

Basics/Arrays/Array2D/Array2D.pde

@@ -0,0 +1,41 @@
+/**
+ * Array 2D. 
+ * 
+ * Demonstrates the syntax for creating a two-dimensional (2D) array.
+ * Values in a 2D array are accessed through two index values.  
+ * 2D arrays are useful for storing images. In this example, each dot 
+ * is colored in relation to its distance from the center of the image. 
+ */
+
+float[][] distances;
+float maxDistance;
+int spacer;
+
+void setup() {
+  size(640, 360);
+  maxDistance = dist(width/2, height/2, width, height);
+  distances = new float[width][height];
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
+      float distance = dist(width/2, height/2, x, y);
+      distances[x][y] = distance/maxDistance * 255;
+    }
+  }
+  spacer = 10;
+  strokeWeight(6);
+  noLoop();  // Run once and stop
+}
+
+void draw() {
+  background(0);
+  // This embedded loop skips over values in the arrays based on
+  // the spacer variable, so there are more values in the array
+  // than are drawn here. Change the value of the spacer variable
+  // to change the density of the points
+  for (int y = 0; y < height; y += spacer) {
+    for (int x = 0; x < width; x += spacer) {
+      stroke(distances[x][y]);
+      point(x + spacer/2, y + spacer/2);
+    }
+  }
+}

Basics/Arrays/ArrayObjects/ArrayObjects.pde

@@ -0,0 +1,33 @@
+/**
+ * Array Objects. 
+ * 
+ * Demonstrates the syntax for creating an array of custom objects. 
+ */
+
+int unit = 40;
+int count;
+Module[] mods;
+
+void setup() {
+  size(640, 360);
+  noStroke();
+  int wideCount = width / unit;
+  int highCount = height / unit;
+  count = wideCount * highCount;
+  mods = new Module[count];
+
+  int index = 0;
+  for (int y = 0; y < highCount; y++) {
+    for (int x = 0; x < wideCount; x++) {
+      mods[index++] = new Module(x*unit, y*unit, unit/2, unit/2, random(0.05, 0.8), unit);
+    }
+  }
+}
+
+void draw() {
+  background(0);
+  for (Module mod : mods) {
+    mod.update();
+    mod.display();
+  }
+}

Basics/Arrays/ArrayObjects/Module.pde

@@ -0,0 +1,39 @@
+class Module {
+  int xOffset;
+  int yOffset;
+  float x, y;
+  int unit;
+  int xDirection = 1;
+  int yDirection = 1;
+  float speed; 
+  
+  // Contructor
+  Module(int xOffsetTemp, int yOffsetTemp, int xTemp, int yTemp, float speedTemp, int tempUnit) {
+    xOffset = xOffsetTemp;
+    yOffset = yOffsetTemp;
+    x = xTemp;
+    y = yTemp;
+    speed = speedTemp;
+    unit = tempUnit;
+  }
+  
+  // Custom method for updating the variables
+  void update() {
+    x = x + (speed * xDirection);
+    if (x >= unit || x <= 0) {
+      xDirection *= -1;
+      x = x + (1 * xDirection);
+      y = y + (1 * yDirection);
+    }
+    if (y >= unit || y <= 0) {
+      yDirection *= -1;
+      y = y + (1 * yDirection);
+    }
+  }
+  
+  // Custom method for drawing the object
+  void display() {
+    fill(255);
+    ellipse(xOffset + x, yOffset + y, 6, 6);
+  }
+}

Basics/Camera/MoveEye/MoveEye.pde

@@ -0,0 +1,28 @@
+/**
+ * Move Eye. 
+ * by Simon Greenwold.
+ * 
+ * The camera lifts up (controlled by mouseY) while looking at the same point.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  fill(204);
+}
+
+void draw() {
+  lights();
+  background(0);
+  
+  // Change height of the camera with mouseY
+  camera(30.0, mouseY, 220.0, // eyeX, eyeY, eyeZ
+         0.0, 0.0, 0.0, // centerX, centerY, centerZ
+         0.0, 1.0, 0.0); // upX, upY, upZ
+  
+  noStroke();
+  box(90);
+  stroke(255);
+  line(-100, 0, 0, 100, 0, 0);
+  line(0, -100, 0, 0, 100, 0);
+  line(0, 0, -100, 0, 0, 100);
+}

Basics/Camera/Orthographic/Orthographic.pde

@@ -0,0 +1,40 @@
+/**
+ * Perspective vs. Ortho
+ *
+ * Move the mouse left to right to change the "far" 
+ * parameter for the perspective() and ortho() functions.
+ * This parameter sets the maximum distance from the 
+ * origin away from the viewer and will clip the geometry.
+ * Click a mouse button to switch between the perspective and
+ * orthographic projections.
+ */
+
+
+boolean showPerspective = false;
+
+void setup() {
+  size(600, 360, P3D);
+  noFill();
+  fill(255);
+  noStroke();
+}
+
+void draw() {
+  lights();
+  background(0);
+  float far = map(mouseX, 0, width, 120, 400);
+  if (showPerspective == true) {
+    perspective(PI/3.0, float(width)/float(height), 10, far);
+  } else {
+    ortho(-width/2.0, width/2.0, -height/2.0, height/2.0, 10, far);
+  }
+  translate(width/2, height/2, 0);
+  rotateX(-PI/6);
+  rotateY(PI/3);
+  box(180);
+}
+
+void mousePressed() {
+  showPerspective = !showPerspective;
+}
+

Basics/Camera/Perspective/Perspective.pde

@@ -0,0 +1,40 @@
+/**
+ * Perspective. 
+ * 
+ * Move the mouse left and right to change the field of view (fov).
+ * Click to modify the aspect ratio. The perspective() function
+ * sets a perspective projection applying foreshortening, making 
+ * distant objects appear smaller than closer ones. The parameters 
+ * define a viewing volume with the shape of truncated pyramid. 
+ * Objects near to the front of the volume appear their actual size, 
+ * while farther objects appear smaller. This projection simulates 
+ * the perspective of the world more accurately than orthographic projection. 
+ * The version of perspective without parameters sets the default 
+ * perspective and the version with four parameters allows the programmer 
+ * to set the area precisely.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() {
+  lights();
+  background(0);
+  float cameraY = height/2.0;
+  float fov = mouseX/float(width) * PI/2;
+  float cameraZ = cameraY / tan(fov / 2.0);
+  float aspect = float(width)/float(height);
+  if (mousePressed) {
+    aspect = aspect / 2.0;
+  }
+  perspective(fov, aspect, cameraZ/10.0, cameraZ*10.0);
+  
+  translate(width/2+30, height/2, 0);
+  rotateX(-PI/6);
+  rotateY(PI/3 + mouseY/float(height) * PI);
+  box(45);
+  translate(0, 0, -50);
+  box(30);
+}

Basics/Color/Brightness/Brightness.pde

@@ -0,0 +1,27 @@
+/**
+ * Brightness 
+ * by Rusty Robison. 
+ * 
+ * Brightness is the relative lightness or darkness of a color.
+ * Move the cursor vertically over each bar to alter its brightness. 
+ */
+ 
+int barWidth = 20;
+int lastBar = -1;
+
+void setup() {
+  size(640, 360);
+  colorMode(HSB, width, 100, height);
+  noStroke();
+  background(0);
+}
+
+void draw() {
+  int whichBar = mouseX / barWidth;
+  if (whichBar != lastBar) {
+    int barX = whichBar * barWidth;
+    fill(barX, 100, mouseY);
+    rect(barX, 0, barWidth, height);
+    lastBar = whichBar;
+  }
+}

Basics/Color/ColorVariables/ColorVariables.pde

@@ -0,0 +1,40 @@
+/**
+ * Color Variables (Homage to Albers). 
+ * 
+ * This example creates variables for colors that may be referred to 
+ * in the program by a name, rather than a number. 
+ */
+
+size(640, 360);
+noStroke();
+background(51, 0, 0);
+
+color inside = color(204, 102, 0);
+color middle = color(204, 153, 0);
+color outside = color(153, 51, 0);
+
+// These statements are equivalent to the statements above.
+// Programmers may use the format they prefer.
+//color inside = #CC6600;
+//color middle = #CC9900;
+//color outside = #993300;
+
+pushMatrix();
+translate(80, 80);
+fill(outside);
+rect(0, 0, 200, 200);
+fill(middle);
+rect(40, 60, 120, 120);
+fill(inside);
+rect(60, 90, 80, 80);
+popMatrix();
+
+pushMatrix();
+translate(360, 80);
+fill(inside);
+rect(0, 0, 200, 200);
+fill(outside);
+rect(40, 60, 120, 120);
+fill(middle);
+rect(60, 90, 80, 80);
+popMatrix();

Basics/Color/Hue/Hue.pde

@@ -0,0 +1,30 @@
+/**
+ * Hue. 
+ * 
+ * Hue is the color reflected from or transmitted through an object 
+ * and is typically referred to as the name of the color (red, blue, yellow, etc.) 
+ * Move the cursor vertically over each bar to alter its hue. 
+ */
+ 
+int barWidth = 20;
+int lastBar = -1;
+
+void setup() 
+{
+  size(640, 360);
+  colorMode(HSB, height, height, height);  
+  noStroke();
+  background(0);
+}
+
+void draw() 
+{
+  int whichBar = mouseX / barWidth;
+  if (whichBar != lastBar) {
+    int barX = whichBar * barWidth;
+    fill(mouseY, height, height);
+    rect(barX, 0, barWidth, height);
+    lastBar = whichBar;
+  }
+}
+