diff --git a/java/examples/Basics/Lights/MixtureGrid/MixtureGrid.pde b/java/examples/Basics/Lights/MixtureGrid/MixtureGrid.pde
new file mode 100644
index 000000000..da5d86127
--- /dev/null
+++ b/java/examples/Basics/Lights/MixtureGrid/MixtureGrid.pde
@@ -0,0 +1,43 @@
+/**
+ * Mixture Grid  
+ * modified from an example by Simon Greenwold. 
+ * 
+ * Display a 2D grid of boxes with three different kinds of lights. 
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() {
+  defineLights();
+  background(0);
+  
+  for (int x = 0; x <= width; x += 60) {
+    for (int y = 0; y <= height; y += 60) {
+      pushMatrix();
+      translate(x, y);
+      rotateY(map(mouseX, 0, width, 0, PI));
+      rotateX(map(mouseY, 0, height, 0, PI));
+      box(90);
+      popMatrix();
+    }
+  }
+}
+
+void defineLights() {
+  // Orange point light on the right
+  pointLight(150, 100, 0,   // Color
+             200, -150, 0); // Position
+
+  // Blue directional light from the left
+  directionalLight(0, 102, 255, // Color
+                   1, 0, 0);    // The x-, y-, z-axis direction
+
+  // Yellow spotlight from the front
+  spotLight(255, 255, 109,  // Color
+            0, 40, 200,     // Position
+            0, -0.5, -0.5,  // Direction
+            PI / 2, 2);     // Angle, concentration
+}
diff --git a/java/examples/Topics/Geometry/NoiseSphere/NoiseSphere.pde b/java/examples/Topics/Geometry/NoiseSphere/NoiseSphere.pde
new file mode 100644
index 000000000..165885339
--- /dev/null
+++ b/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();
+  }
+}
+
diff --git a/java/examples/Topics/Geometry/SpaceJunk/Cube.pde b/java/examples/Topics/Geometry/SpaceJunk/Cube.pde
new file mode 100644
index 000000000..121b33f9b
--- /dev/null
+++ b/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));
+  }
+}
diff --git a/java/examples/Topics/Geometry/SpaceJunk/SpaceJunk.pde b/java/examples/Topics/Geometry/SpaceJunk/SpaceJunk.pde
new file mode 100644
index 000000000..d47f91652
--- /dev/null
+++ b/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 ang;
+
+// 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 change 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(ang));
+  rotateX(radians(ang));
+
+  // Draw cubes
+  for (int i = 0; i < cubes.length; i++){
+    cubes[i].drawCube();
+  }
+  
+  // Used in rotate function calls above
+  ang += 0.2;
+}
+
+
diff --git a/java/examples/Topics/Textures/TextureSphere/TextureSphere.pde b/java/examples/Topics/Textures/TextureSphere/TextureSphere.pde
new file mode 100644
index 000000000..412cd1b2b
--- /dev/null
+++ b/java/examples/Topics/Textures/TextureSphere/TextureSphere.pde
@@ -0,0 +1,174 @@
+/**
+ * Texture Sphere 
+ * by Mike 'Flux' Chang (cleaned up by Aaron Koblin). 
+ * Based on code by Toxi. 
+ * 
+ * A 3D textured sphere with simple rotation control.
+ * Note: Controls will be inverted when sphere is upside down. 
+ * Use an "arc ball" to deal with this appropriately.
+ */ 
+
+// The next line is needed if running in JavaScript Mode with Processing.js
+/* @pjs preload="world32k.jpg"; */ 
+
+PImage bg;
+PImage texmap;
+
+int sDetail = 35;  // Sphere detail setting
+float rotationX = 0;
+float rotationY = 0;
+float velocityX = 0;
+float velocityY = 0;
+float globeRadius = 400;
+float pushBack = 0;
+
+float[] cx, cz, sphereX, sphereY, sphereZ;
+float sinLUT[];
+float cosLUT[];
+float SINCOS_PRECISION = 0.5;
+int SINCOS_LENGTH = int(360.0 / SINCOS_PRECISION);
+
+
+void setup() {
+  size(640, 360, P3D);  
+  texmap = loadImage("world32k.jpg");    
+  initializeSphere(sDetail);
+}
+
+void draw() {    
+  background(0);            
+  renderGlobe(); 
+}
+
+void renderGlobe() {
+  pushMatrix();
+  translate(width * 0.33, height * 0.5, pushBack);
+  pushMatrix();
+  noFill();
+  stroke(255,200);
+  strokeWeight(2);
+  smooth();
+  popMatrix();
+  lights();    
+  pushMatrix();
+  rotateX( radians(-rotationX) );  
+  rotateY( radians(270 - rotationY) );
+  fill(200);
+  noStroke();
+  textureMode(IMAGE);  
+  texturedSphere(globeRadius, texmap);
+  popMatrix();  
+  popMatrix();
+  rotationX += velocityX;
+  rotationY += velocityY;
+  velocityX *= 0.95;
+  velocityY *= 0.95;
+  
+  // Implements mouse control (interaction will be inverse when sphere is  upside down)
+  if(mousePressed){
+    velocityX += (mouseY-pmouseY) * 0.01;
+    velocityY -= (mouseX-pmouseX) * 0.01;
+  }
+}
+
+void initializeSphere(int res)
+{
+  sinLUT = new float[SINCOS_LENGTH];
+  cosLUT = new float[SINCOS_LENGTH];
+
+  for (int i = 0; i < SINCOS_LENGTH; i++) {
+    sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
+    cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
+  }
+
+  float delta = (float)SINCOS_LENGTH/res;
+  float[] cx = new float[res];
+  float[] cz = new float[res];
+  
+  // Calc unit circle in XZ plane
+  for (int i = 0; i < res; i++) {
+    cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
+    cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
+  }
+  
+  // Computing vertexlist vertexlist starts at south pole
+  int vertCount = res * (res-1) + 2;
+  int currVert = 0;
+  
+  // Re-init arrays to store vertices
+  sphereX = new float[vertCount];
+  sphereY = new float[vertCount];
+  sphereZ = new float[vertCount];
+  float angle_step = (SINCOS_LENGTH*0.5f)/res;
+  float angle = angle_step;
+  
+  // Step along Y axis
+  for (int i = 1; i < res; i++) {
+    float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
+    float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
+    for (int j = 0; j < res; j++) {
+      sphereX[currVert] = cx[j] * curradius;
+      sphereY[currVert] = currY;
+      sphereZ[currVert++] = cz[j] * curradius;
+    }
+    angle += angle_step;
+  }
+  sDetail = res;
+}
+
+// Generic routine to draw textured sphere
+void texturedSphere(float r, PImage t) {
+  int v1,v11,v2;
+  r = (r + 240 ) * 0.33;
+  beginShape(TRIANGLE_STRIP);
+  texture(t);
+  float iu=(float)(t.width-1)/(sDetail);
+  float iv=(float)(t.height-1)/(sDetail);
+  float u=0,v=iv;
+  for (int i = 0; i < sDetail; i++) {
+    vertex(0, -r, 0,u,0);
+    vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
+    u+=iu;
+  }
+  vertex(0, -r, 0,u,0);
+  vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
+  endShape();   
+  
+  // Middle rings
+  int voff = 0;
+  for(int i = 2; i < sDetail; i++) {
+    v1=v11=voff;
+    voff += sDetail;
+    v2=voff;
+    u=0;
+    beginShape(TRIANGLE_STRIP);
+    texture(t);
+    for (int j = 0; j < sDetail; j++) {
+      vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
+      vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
+      u+=iu;
+    }
+  
+    // Close each ring
+    v1=v11;
+    v2=voff;
+    vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
+    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
+    endShape();
+    v+=iv;
+  }
+  u=0;
+  
+  // Add the northern cap
+  beginShape(TRIANGLE_STRIP);
+  texture(t);
+  for (int i = 0; i < sDetail; i++) {
+    v2 = voff + i;
+    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
+    vertex(0, r, 0,u,v+iv);    
+    u+=iu;
+  }
+  vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
+  endShape();
+  
+}