Initial Commit

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Icosahedra/Dimension3D.pde

@@ -0,0 +1,10 @@
+class Dimension3D{
+   float w, h, d;
+   
+   Dimension3D(float w, float h, float d){
+     this.w=w;
+     this.h=h;
+     this.d=d;
+  }
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Icosahedra/Icosahedra.pde

@@ -0,0 +1,52 @@
+/**
+ * I Like Icosahedra
+ * by Ira Greenberg.
+ * 
+ * This example plots icosahedra. The Icosahdron is a regular
+ * polyhedron composed of twenty equalateral triangles.
+ */
+ 
+Icosahedron ico1;
+Icosahedron ico2;
+Icosahedron ico3;
+
+void setup(){
+  size(640, 360, P3D);
+  ico1 = new Icosahedron(75);
+  ico2 = new Icosahedron(75);
+  ico3 = new Icosahedron(75);
+}
+
+void draw(){
+  background(0);
+  lights();
+  translate(width/2, height/2);
+
+  pushMatrix();
+  translate(-width/3.5, 0);
+  rotateX(frameCount*PI/185);
+  rotateY(frameCount*PI/-200);
+  stroke(170, 0, 0);
+  noFill();
+  ico1.create();
+  popMatrix();
+
+  pushMatrix();
+  rotateX(frameCount*PI/200);
+  rotateY(frameCount*PI/300);
+  stroke(150, 0, 180);
+  fill(170, 170, 0);
+  ico2.create();
+  popMatrix();
+
+  pushMatrix();
+  translate(width/3.5, 0);
+  rotateX(frameCount*PI/-200);
+  rotateY(frameCount*PI/200);
+  noStroke();
+  fill(0, 0, 185);
+  ico3.create();
+  popMatrix();
+}
+
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Icosahedra/Icosahedron.pde

@@ -0,0 +1,159 @@
+class Icosahedron extends Shape3D{
+
+  // icosahedron
+  PVector topPoint;
+  PVector[] topPent = new PVector[5];
+  PVector bottomPoint;
+  PVector[] bottomPent = new PVector[5];
+  float angle = 0, radius = 150;
+  float triDist;
+  float triHt;
+  float a, b, c;
+
+  // constructor
+  Icosahedron(float radius){
+    this.radius = radius;
+    init();
+  }
+
+  Icosahedron(PVector v, float radius){
+    super(v);
+    this.radius = radius;
+    init();
+  }
+
+  // calculate geometry
+  void init(){
+    c = dist(cos(0)*radius, sin(0)*radius, cos(radians(72))*radius,  sin(radians(72))*radius);
+    b = radius;
+    a = (float)(Math.sqrt(((c*c)-(b*b))));
+
+    triHt = (float)(Math.sqrt((c*c)-((c/2)*(c/2))));
+
+    for (int i=0; i<topPent.length; i++){
+      topPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, triHt/2.0f);
+      angle+=radians(72);
+    }
+    topPoint = new PVector(0, 0, triHt/2.0f+a);
+    angle = 72.0f/2.0f;
+    for (int i=0; i<topPent.length; i++){
+      bottomPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, -triHt/2.0f);
+      angle+=radians(72);
+    }
+    bottomPoint = new PVector(0, 0, -(triHt/2.0f+a));
+  }
+
+  // draws icosahedron 
+  void create(){
+    for (int i=0; i<topPent.length; i++){
+      // icosahedron top
+      beginShape();
+      if (i<topPent.length-1){
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+      } 
+      else {
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
+        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
+      }
+      endShape(CLOSE);
+
+      // icosahedron bottom
+      beginShape();
+      if (i<bottomPent.length-1){
+        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
+        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+      } 
+      else {
+        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
+        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+      }
+      endShape(CLOSE);
+    }
+
+    // icosahedron body
+    for (int i=0; i<topPent.length; i++){
+      if (i<topPent.length-2){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+        endShape(CLOSE);
+      } 
+      else if (i==topPent.length-2){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+        endShape(CLOSE);
+      }
+      else if (i==topPent.length-1){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
+        endShape(CLOSE);
+      }
+    }
+  }
+
+  // overrided methods fom Shape3D
+  void rotZ(float theta){
+    float tx=0, ty=0, tz=0;
+    // top point
+    tx = cos(theta)*topPoint.x+sin(theta)*topPoint.y;
+    ty = sin(theta)*topPoint.x-cos(theta)*topPoint.y;
+    topPoint.x = tx;
+    topPoint.y = ty;
+
+    // bottom point
+    tx = cos(theta)*bottomPoint.x+sin(theta)*bottomPoint.y;
+    ty = sin(theta)*bottomPoint.x-cos(theta)*bottomPoint.y;
+    bottomPoint.x = tx;
+    bottomPoint.y = ty;
+
+    // top and bottom pentagons
+    for (int i=0; i<topPent.length; i++){
+      tx = cos(theta)*topPent[i].x+sin(theta)*topPent[i].y;
+      ty = sin(theta)*topPent[i].x-cos(theta)*topPent[i].y;
+      topPent[i].x = tx;
+      topPent[i].y = ty;
+
+      tx = cos(theta)*bottomPent[i].x+sin(theta)*bottomPent[i].y;
+      ty = sin(theta)*bottomPent[i].x-cos(theta)*bottomPent[i].y;
+      bottomPent[i].x = tx;
+      bottomPent[i].y = ty;
+    }
+  }
+
+  void rotX(float theta){
+  }
+
+  void rotY(float theta){
+  }
+
+
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Icosahedra/Shape3D.pde

@@ -0,0 +1,82 @@
+abstract class Shape3D{
+  float x, y, z;
+  float w, h, d;
+
+  Shape3D(){
+  }
+
+  Shape3D(float x, float y, float z){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  Shape3D(PVector p){
+    x = p.x;
+    y = p.y;
+    z = p.z;
+  }
+
+
+  Shape3D(Dimension3D dim){
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  Shape3D(float x, float y, float z, float w, float h, float d){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    this.h = h;
+    this.d = d;
+  }
+
+  Shape3D(float x, float y, float z, Dimension3D dim){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  Shape3D(PVector p, Dimension3D dim){
+    x = p.x;
+    y = p.y;
+    z = p.z;
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  void setLoc(PVector p){
+    x=p.x;
+    y=p.y;
+    z=p.z;
+  }
+
+  void setLoc(float x, float y, float z){
+    this.x=x;
+    this.y=y;
+    this.z=z;
+  }
+
+
+  // override if you need these
+  void rotX(float theta){
+  }
+
+  void rotY(float theta){
+  }
+
+  void rotZ(float theta){
+  }
+
+
+  // must be implemented in subclasses
+  abstract void init();
+  abstract void create();
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/NoiseSphere/NoiseSphere.pde

@@ -0,0 +1,82 @@
+/**
+ * Noise Sphere 
+ * by David Pena.  
+ * 
+ * Uniform random distribution on the surface of a sphere. 
+ */
+
+int cuantos = 4000;
+Pelo[] lista ;
+float[] z = new float[cuantos]; 
+float[] phi = new float[cuantos]; 
+float[] largos = new float[cuantos]; 
+float radio;
+float rx = 0;
+float ry =0;
+
+void setup() {
+  size(640, 360, P3D);
+  radio = height/3;
+  lista = new Pelo[cuantos];
+  for (int i=0; i<cuantos; i++) {
+    lista[i] = new Pelo();
+  }
+  noiseDetail(3);
+}
+
+void draw() {
+  background(0);
+  translate(width/2, height/2);
+
+  float rxp = ((mouseX-(width/2))*0.005);
+  float ryp = ((mouseY-(height/2))*0.005);
+  rx = (rx*0.9)+(rxp*0.1);
+  ry = (ry*0.9)+(ryp*0.1);
+  rotateY(rx);
+  rotateX(ry);
+  fill(0);
+  noStroke();
+  sphere(radio);
+
+  for (int i = 0;i < cuantos; i++) {
+    lista[i].dibujar();
+  }
+}
+
+
+class Pelo {
+  
+  float z = random(-radio, radio);
+  float phi = random(TWO_PI);
+  float largo = random(1.15, 1.2);
+  float theta = asin(z/radio);
+
+  void dibujar() {
+    float off = (noise(millis() * 0.0005, sin(phi))-0.5) * 0.3;
+    float offb = (noise(millis() * 0.0007, sin(z) * 0.01)-0.5) * 0.3;
+
+    float thetaff = theta+off;
+    float phff = phi+offb;
+    float x = radio * cos(theta) * cos(phi);
+    float y = radio * cos(theta) * sin(phi);
+    float z = radio * sin(theta);
+    float msx= screenX(x, y, z);
+    float msy= screenY(x, y, z);
+
+    float xo = radio * cos(thetaff) * cos(phff);
+    float yo = radio * cos(thetaff) * sin(phff);
+    float zo = radio * sin(thetaff);
+
+    float xb = xo * largo;
+    float yb = yo * largo;
+    float zb = zo * largo;
+
+    beginShape(LINES);
+    stroke(0);
+    vertex(x, y, z);
+    stroke(200, 150);
+    vertex(xb, yb, zb);
+    endShape();
+  }
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/RGBCube/RGBCube.pde

@@ -0,0 +1,75 @@
+/**
+ * RGB Cube.
+ * 
+ * The three primary colors of the additive color model are red, green, and blue.
+ * This RGB color cube displays smooth transitions between these colors. 
+ */
+ 
+float xmag, ymag = 0;
+float newXmag, newYmag = 0; 
+ 
+void setup()  { 
+  size(640, 360, P3D); 
+  noStroke(); 
+  colorMode(RGB, 1); 
+} 
+ 
+void draw()  { 
+  background(0.5);
+  
+  pushMatrix(); 
+  translate(width/2, height/2, -30); 
+  
+  newXmag = mouseX/float(width) * TWO_PI;
+  newYmag = mouseY/float(height) * TWO_PI;
+  
+  float diff = xmag-newXmag;
+  if (abs(diff) >  0.01) { 
+    xmag -= diff/4.0; 
+  }
+  
+  diff = ymag-newYmag;
+  if (abs(diff) >  0.01) { 
+    ymag -= diff/4.0; 
+  }
+  
+  rotateX(-ymag); 
+  rotateY(-xmag); 
+  
+  scale(90);
+  beginShape(QUADS);
+
+  fill(0, 1, 1); vertex(-1,  1,  1);
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(0, 0, 0); vertex(-1, -1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(0, 1, 1); vertex(-1,  1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+  fill(0, 0, 0); vertex(-1, -1, -1);
+
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(0, 1, 1); vertex(-1,  1,  1);
+
+  fill(0, 0, 0); vertex(-1, -1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+
+  endShape();
+  
+  popMatrix(); 
+} 

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/ShapeTransform/ShapeTransform.pde

@@ -0,0 +1,116 @@
+/**
+ * Shape Transform
+ * by Ira Greenberg.  
+ * 
+ * Illustrates the geometric relationship 
+ * between Cube, Pyramid, Cone and 
+ * Cylinder 3D primitives.
+ * 
+ * Instructions:<br />
+ * Up Arrow - increases points<br />
+ * Down Arrow - decreases points<br />
+ * 'p' key toggles between cube/pyramid<br />
+ */
+
+int pts = 4; 
+float angle = 0;
+float radius = 99;
+float cylinderLength = 95;
+
+//vertices
+PVector vertices[][];
+boolean isPyramid = false;
+
+float angleInc;
+
+void setup(){
+  size(640, 360, P3D);
+  noStroke();
+  angleInc = PI/300.0;
+}
+
+void draw(){
+  background(170, 95, 95);
+  lights();
+  fill(255, 200, 200);
+  translate(width/2, height/2);
+  rotateX(frameCount * angleInc);
+  rotateY(frameCount * angleInc);
+  rotateZ(frameCount * angleInc);
+
+  // initialize vertex arrays
+  vertices = new PVector[2][pts+1];
+
+  // fill arrays
+  for (int i = 0; i < 2; i++){
+    angle = 0;
+    for(int j = 0; j <= pts; j++){
+      vertices[i][j] = new PVector();
+      if (isPyramid){
+        if (i==1){
+          vertices[i][j].x = 0;
+          vertices[i][j].y = 0;
+        }
+        else {
+          vertices[i][j].x = cos(radians(angle)) * radius;
+          vertices[i][j].y = sin(radians(angle)) * radius;
+        }
+      } 
+      else {
+        vertices[i][j].x = cos(radians(angle)) * radius;
+        vertices[i][j].y = sin(radians(angle)) * radius;
+      }
+      vertices[i][j].z = cylinderLength; 
+      // the .0 after the 360 is critical
+      angle += 360.0/pts;
+    }
+    cylinderLength *= -1;
+  }
+
+  // draw cylinder tube
+  beginShape(QUAD_STRIP);
+  for(int j = 0; j <= pts; j++){
+    vertex(vertices[0][j].x, vertices[0][j].y, vertices[0][j].z);
+    vertex(vertices[1][j].x, vertices[1][j].y, vertices[1][j].z);
+  }
+  endShape();
+
+  //draw cylinder ends
+  for (int i = 0; i < 2; i++){
+    beginShape();
+    for(int j = 0; j < pts; j++){
+      vertex(vertices[i][j].x, vertices[i][j].y, vertices[i][j].z);
+    }
+    endShape(CLOSE);
+  }
+}
+
+
+/*
+ up/down arrow keys control
+ polygon detail.
+ */
+void keyPressed(){
+  if(key == CODED) { 
+    // pts
+    if (keyCode == UP) { 
+      if (pts < 90){
+        pts++;
+      } 
+    } 
+    else if (keyCode == DOWN) { 
+      if (pts > 4){
+        pts--;
+      }
+    } 
+  }
+  if (key =='p'){
+    if (isPyramid){
+      isPyramid = false;
+    } 
+    else {
+      isPyramid = true;
+    }
+  }
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/SpaceJunk/Cube.pde

@@ -0,0 +1,67 @@
+
+class Cube {
+
+  // Properties
+  int w, h, d;
+  int shiftX, shiftY, shiftZ;
+
+  // Constructor
+  Cube(int w, int h, int d, int shiftX, int shiftY, int shiftZ){
+    this.w = w;
+    this.h = h;
+    this.d = d;
+    this.shiftX = shiftX;
+    this.shiftY = shiftY;
+    this.shiftZ = shiftZ;
+  }
+
+  // Main cube drawing method, which looks 
+  // more confusing than it really is. It's 
+  // just a bunch of rectangles drawn for 
+  // each cube face
+  void drawCube(){
+    beginShape(QUADS);
+    // Front face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Back face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
+
+    // Left face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Right face
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Top face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+
+    // Bottom face
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ); 
+
+    endShape(); 
+
+    // Add some rotation to each box for pizazz.
+    rotateY(radians(1));
+    rotateX(radians(1));
+    rotateZ(radians(1));
+  }
+}

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/SpaceJunk/SpaceJunk.pde

@@ -0,0 +1,61 @@
+/**
+ * Space Junk  
+ * by Ira Greenberg (zoom suggestion by Danny Greenberg).
+ * 
+ * Rotating cubes in space using a custom Cube class. 
+ * Color controlled by light sources. Move the mouse left
+ * and right to zoom.
+ */
+
+// Used for oveall rotation
+float angle;
+
+// Cube count-lower/raise to test performance
+int limit = 500;
+
+// Array for all cubes
+Cube[] cubes = new Cube[limit];
+
+void setup() {
+  size(640, 360, P3D); 
+  background(0); 
+  noStroke();
+
+  // Instantiate cubes, passing in random vals for size and postion
+  for (int i = 0; i < cubes.length; i++){
+    cubes[i] = new Cube(int(random(-10, 10)), int(random(-10, 10)), 
+                        int(random(-10, 10)), int(random(-140, 140)), 
+                        int(random(-140, 140)), int(random(-140, 140)));
+  }
+}
+
+void draw(){
+  background(0); 
+  fill(200);
+
+  // Set up some different colored lights
+  pointLight(51, 102, 255, 65, 60, 100); 
+  pointLight(200, 40, 60, -65, -60, -150);
+
+  // Raise overall light in scene 
+  ambientLight(70, 70, 10); 
+
+  // Center geometry in display windwow.
+  // you can changlee 3rd argument ('0')
+  // to move block group closer(+) / further(-)
+  translate(width/2, height/2, -200 + mouseX * 0.65);
+
+  // Rotate around y and x axes
+  rotateY(radians(angle));
+  rotateX(radians(angle));
+
+  // Draw cubes
+  for (int i = 0; i < cubes.length; i++){
+    cubes[i].drawCube();
+  }
+  
+  // Used in rotate function calls above
+  angle += 0.2;
+}
+
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Toroid/Toroid.pde

@@ -0,0 +1,182 @@
+/**
+ * Interactive Toroid
+ * by Ira Greenberg. 
+ * 
+ * Illustrates the geometric relationship between Toroid, Sphere, and Helix
+ * 3D primitives, as well as lathing principal.
+ * 
+ * Instructions: <br />
+ * UP arrow key pts++ <br />
+ * DOWN arrow key pts-- <br />
+ * LEFT arrow key segments-- <br />
+ * RIGHT arrow key segments++ <br />
+ * 'a' key toroid radius-- <br />
+ * 's' key toroid radius++ <br />
+ * 'z' key initial polygon radius-- <br />
+ * 'x' key initial polygon radius++ <br />
+ * 'w' key toggle wireframe/solid shading <br />
+ * 'h' key toggle sphere/helix <br />
+ */
+
+int pts = 40; 
+float angle = 0;
+float radius = 60.0;
+
+// lathe segments
+int segments = 60;
+float latheAngle = 0;
+float latheRadius = 100.0;
+
+//vertices
+PVector vertices[], vertices2[];
+
+// for shaded or wireframe rendering 
+boolean isWireFrame = false;
+
+// for optional helix
+boolean isHelix = false;
+float helixOffset = 5.0;
+
+void setup(){
+  size(640, 360, P3D);
+}
+
+void draw(){
+  background(50, 64, 42);
+  // basic lighting setup
+  lights();
+  // 2 rendering styles
+  // wireframe or solid
+  if (isWireFrame){
+    stroke(255, 255, 150);
+    noFill();
+  } 
+  else {
+    noStroke();
+    fill(150, 195, 125);
+  }
+  //center and spin toroid
+  translate(width/2, height/2, -100);
+
+  rotateX(frameCount*PI/150);
+  rotateY(frameCount*PI/170);
+  rotateZ(frameCount*PI/90);
+
+  // initialize point arrays
+  vertices = new PVector[pts+1];
+  vertices2 = new PVector[pts+1];
+
+  // fill arrays
+  for(int i=0; i<=pts; i++){
+    vertices[i] = new PVector();
+    vertices2[i] = new PVector();
+    vertices[i].x = latheRadius + sin(radians(angle))*radius;
+    if (isHelix){
+      vertices[i].z = cos(radians(angle))*radius-(helixOffset* 
+        segments)/2;
+    } 
+    else{
+      vertices[i].z = cos(radians(angle))*radius;
+    }
+    angle+=360.0/pts;
+  }
+
+  // draw toroid
+  latheAngle = 0;
+  for(int i=0; i<=segments; i++){
+    beginShape(QUAD_STRIP);
+    for(int j=0; j<=pts; j++){
+      if (i>0){
+        vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
+      }
+      vertices2[j].x = cos(radians(latheAngle))*vertices[j].x;
+      vertices2[j].y = sin(radians(latheAngle))*vertices[j].x;
+      vertices2[j].z = vertices[j].z;
+      // optional helix offset
+      if (isHelix){
+        vertices[j].z+=helixOffset;
+      } 
+      vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
+    }
+    // create extra rotation for helix
+    if (isHelix){
+      latheAngle+=720.0/segments;
+    } 
+    else {
+      latheAngle+=360.0/segments;
+    }
+    endShape();
+  }
+}
+
+/*
+ left/right arrow keys control ellipse detail
+ up/down arrow keys control segment detail.
+ 'a','s' keys control lathe radius
+ 'z','x' keys control ellipse radius
+ 'w' key toggles between wireframe and solid
+ 'h' key toggles between toroid and helix
+ */
+void keyPressed(){
+  if(key == CODED) { 
+    // pts
+    if (keyCode == UP) { 
+      if (pts<40){
+        pts++;
+      } 
+    } 
+    else if (keyCode == DOWN) { 
+      if (pts>3){
+        pts--;
+      }
+    } 
+    // extrusion length
+    if (keyCode == LEFT) { 
+      if (segments>3){
+        segments--; 
+      }
+    } 
+    else if (keyCode == RIGHT) { 
+      if (segments<80){
+        segments++; 
+      }
+    } 
+  }
+  // lathe radius
+  if (key =='a'){
+    if (latheRadius>0){
+      latheRadius--; 
+    }
+  } 
+  else if (key == 's'){
+    latheRadius++; 
+  }
+  // ellipse radius
+  if (key =='z'){
+    if (radius>10){
+      radius--;
+    }
+  } 
+  else if (key == 'x'){
+    radius++;
+  }
+  // wireframe
+  if (key =='w'){
+    if (isWireFrame){
+      isWireFrame=false;
+    } 
+    else {
+      isWireFrame=true;
+    }
+  }
+  // helix
+  if (key =='h'){
+    if (isHelix){
+      isHelix=false;
+    } 
+    else {
+      isHelix=true;
+    }
+  }
+}
+

Java/Processing/processing-3.3.6/modes/java/examples/Topics/Geometry/Vertices/Vertices.pde

@@ -0,0 +1,67 @@
+/**
+ * Vertices 
+ * by Simon Greenwold.
+ * 
+ * Draw a cylinder centered on the y-axis, going down 
+ * from y=0 to y=height. The radius at the top can be 
+ * different from the radius at the bottom, and the 
+ * number of sides drawn is variable.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+}
+
+void draw() {
+  background(0);
+  lights();
+  translate(width / 2, height / 2);
+  rotateY(map(mouseX, 0, width, 0, PI));
+  rotateZ(map(mouseY, 0, height, 0, -PI));
+  noStroke();
+  fill(255, 255, 255);
+  translate(0, -40, 0);
+  drawCylinder(10, 180, 200, 16); // Draw a mix between a cylinder and a cone
+  //drawCylinder(70, 70, 120, 64); // Draw a cylinder
+  //drawCylinder(0, 180, 200, 4); // Draw a pyramid
+}
+
+void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
+  float angle = 0;
+  float angleIncrement = TWO_PI / sides;
+  beginShape(QUAD_STRIP);
+  for (int i = 0; i < sides + 1; ++i) {
+    vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
+    vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
+    angle += angleIncrement;
+  }
+  endShape();
+  
+  // If it is not a cone, draw the circular top cap
+  if (topRadius != 0) {
+    angle = 0;
+    beginShape(TRIANGLE_FAN);
+    
+    // Center point
+    vertex(0, 0, 0);
+    for (int i = 0; i < sides + 1; i++) {
+      vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
+      angle += angleIncrement;
+    }
+    endShape();
+  }
+
+  // If it is not a cone, draw the circular bottom cap
+  if (bottomRadius != 0) {
+    angle = 0;
+    beginShape(TRIANGLE_FAN);
+
+    // Center point
+    vertex(0, tall, 0);
+    for (int i = 0; i < sides + 1; i++) {
+      vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
+      angle += angleIncrement;
+    }
+    endShape();
+  }
+}