Added Post Processing, Improved UI a lot, Made File Explorer look nicer, Fixed up Raycast Selection, Added Placeholder Playmode Button, Added cameras, Organized Create menu in Inspector, Added outlines to selected objects, added view output for viewing cameras while in Playmode area.

Resources/ThirdParty/BloomFilter/BloomFilter.pde

@@ -0,0 +1,144 @@
+import controlP5.*;
+
+ControlP5 cp5;
+
+PGraphics canvas;
+
+PGraphics brightPass;
+PGraphics horizontalBlurPass;
+PGraphics verticalBlurPass;
+
+PShader bloomFilter;
+PShader blurFilter;
+
+int angle = 0;
+
+final int surfaceWidth = 250;
+final int surfaceHeight = 250;
+
+float luminanceFilter = 0.8;
+float blurSize = 20;
+float sigma = 12;
+
+void setup()
+{
+  size(1000, 250, P3D);
+
+  addUI();
+
+  canvas = createGraphics(surfaceWidth, surfaceHeight, P3D);
+  
+  brightPass = createGraphics(surfaceWidth, surfaceHeight, P2D);
+  brightPass.noSmooth();
+
+  horizontalBlurPass = createGraphics(surfaceWidth, surfaceHeight, P2D);
+  horizontalBlurPass.noSmooth(); 
+
+  verticalBlurPass = createGraphics(surfaceWidth, surfaceHeight, P2D);
+  verticalBlurPass.noSmooth(); 
+
+  bloomFilter = loadShader("bloomFrag.glsl");
+  blurFilter = loadShader("blurFrag.glsl");
+}
+
+void draw()
+{
+  background(0);
+
+  bloomFilter.set("brightPassThreshold", luminanceFilter);
+
+  blurFilter.set("blurSize", (int)blurSize);
+  blurFilter.set("sigma", sigma); 
+
+  canvas.beginDraw();
+  render(canvas);
+  canvas.endDraw();
+
+  // bright pass
+  brightPass.beginDraw();
+  brightPass.shader(bloomFilter);
+  brightPass.image(canvas, 0, 0);
+  brightPass.endDraw();
+
+  // blur horizontal pass
+  horizontalBlurPass.beginDraw();
+  blurFilter.set("horizontalPass", 1);
+  horizontalBlurPass.shader(blurFilter);
+  horizontalBlurPass.image(brightPass, 0, 0);
+  horizontalBlurPass.endDraw();
+
+  // blur vertical pass
+  verticalBlurPass.beginDraw();
+  blurFilter.set("horizontalPass", 0);
+  verticalBlurPass.shader(blurFilter);
+  verticalBlurPass.image(horizontalBlurPass, 0, 0);
+  verticalBlurPass.endDraw();
+
+  // draw original
+  image(canvas.copy(), 0, 0);
+  text("Original", 20, height - 20); 
+
+  // draw bright pass
+  image(brightPass, surfaceWidth, 0);
+  text("Bright Pass", surfaceWidth + 20, height - 20); 
+
+  image(verticalBlurPass, (surfaceWidth * 2), 0);
+  text("Blur", (surfaceWidth * 2) + 20, height - 20); 
+
+  // draw 
+  image(canvas, (surfaceWidth * 3), 0);
+  blendMode(SCREEN);
+  image(verticalBlurPass, (surfaceWidth * 3), 0);
+  blendMode(BLEND);
+  text("Combined", (surfaceWidth * 3) + 20, height - 20); 
+
+  // fps
+  fill(0, 255, 0);
+  text("FPS: " + frameRate, 20, 20);
+}
+
+void render(PGraphics pg)
+{
+  pg.background(0, 0);
+  pg.stroke(255, 0, 0);
+
+  for (int i = -1; i < 2; i++)
+  {
+    if (i == -1)
+      pg.fill(0, 255, 0);
+    else if (i == 0)
+      pg.fill(255);
+    else
+      pg.fill(0, 200, 200);
+
+    pg.pushMatrix();
+    // left-right, up-down, near-far
+    pg.translate(surfaceWidth / 2 + (i * 50), surfaceHeight / 2, 0);
+    pg.rotateX(radians(angle));
+    pg.rotateZ(radians(angle));
+    pg.box(30);
+    pg.popMatrix();
+  }
+
+  angle = ++angle % 360;
+}
+
+void addUI()
+{
+  cp5 = new ControlP5(this);
+
+  cp5.addSlider("luminanceFilter")
+    .setPosition(200, 5)
+    .setRange(0, 1)
+    ;
+
+  cp5.addSlider("blurSize")
+    .setPosition(400, 5)
+    .setRange(0, 100)
+    ;
+
+  cp5.addSlider("sigma")
+    .setPosition(600, 5)
+    .setRange(1, 100)
+    ;
+}

Resources/ThirdParty/BloomFilter/bloomFrag.glsl

@@ -0,0 +1,23 @@
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+uniform sampler2D texture;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+uniform float brightPassThreshold;
+
+void main() {
+	vec3 luminanceVector = vec3(0.2125, 0.7154, 0.0721);
+    vec4 c = texture2D(texture, vertTexCoord.st) * vertColor;
+
+    float luminance = dot(luminanceVector, c.xyz);
+    luminance = max(0.0, luminance - brightPassThreshold);
+    c.xyz *= sign(luminance);
+    c.a = 1.0;
+
+    gl_FragColor = c;
+}

Resources/ThirdParty/BloomFilter/bloomVert.glsl

@@ -0,0 +1,18 @@
+#define PROCESSING_TEXTURE_SHADER
+
+uniform mat4 transform;
+uniform mat4 texMatrix;
+
+attribute vec4 vertex;
+attribute vec4 color;
+attribute vec2 texCoord;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+void main() {
+  gl_Position = transform * vertex;
+    
+  vertColor = color;
+  vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0);
+}

Resources/ThirdParty/BloomFilter/blurFrag.glsl

@@ -0,0 +1,59 @@
+// Adapted from:
+// <a href="http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html" target="_blank" rel="nofollow">http://callumhay.blogspot.com/2010/09/gaussian-blur-shader-glsl.html</a>
+ 
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+ 
+#define PROCESSING_TEXTURE_SHADER
+ 
+uniform sampler2D texture;
+ 
+// The inverse of the texture dimensions along X and Y
+uniform vec2 texOffset;
+ 
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+ 
+uniform int blurSize;       
+uniform int horizontalPass; // 0 or 1 to indicate vertical or horizontal pass
+uniform float sigma;        // The sigma value for the gaussian function: higher value means more blur
+                            // A good value for 9x9 is around 3 to 5
+                            // A good value for 7x7 is around 2.5 to 4
+                            // A good value for 5x5 is around 2 to 3.5
+                            // ... play around with this based on what you need <span class="Emoticon Emoticon1"><span>:)</span></span>
+ 
+const float pi = 3.14159265;
+ 
+void main() {  
+  float numBlurPixelsPerSide = float(blurSize / 2); 
+ 
+  vec2 blurMultiplyVec = 0 < horizontalPass ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+ 
+  // Incremental Gaussian Coefficent Calculation (See GPU Gems 3 pp. 877 - 889)
+  vec3 incrementalGaussian;
+  incrementalGaussian.x = 1.0 / (sqrt(2.0 * pi) * sigma);
+  incrementalGaussian.y = exp(-0.5 / (sigma * sigma));
+  incrementalGaussian.z = incrementalGaussian.y * incrementalGaussian.y;
+ 
+  vec4 avgValue = vec4(0.0, 0.0, 0.0, 0.0);
+  float coefficientSum = 0.0;
+ 
+  // Take the central sample first...
+  avgValue += texture2D(texture, vertTexCoord.st) * incrementalGaussian.x;
+  coefficientSum += incrementalGaussian.x;
+  incrementalGaussian.xy *= incrementalGaussian.yz;
+ 
+  // Go through the remaining 8 vertical samples (4 on each side of the center)
+  for (float i = 1.0; i <= numBlurPixelsPerSide; i++) { 
+    avgValue += texture2D(texture, vertTexCoord.st - i * texOffset * 
+                          blurMultiplyVec) * incrementalGaussian.x;         
+    avgValue += texture2D(texture, vertTexCoord.st + i * texOffset * 
+                          blurMultiplyVec) * incrementalGaussian.x;         
+    coefficientSum += 2.0 * incrementalGaussian.x;
+    incrementalGaussian.xy *= incrementalGaussian.yz;
+  }
+ 
+  gl_FragColor = avgValue / coefficientSum;
+}

Resources/ThirdParty/BloomFilter/blurVert.glsl

@@ -0,0 +1,18 @@
+#define PROCESSING_TEXTURE_SHADER
+
+uniform mat4 transform;
+uniform mat4 texMatrix;
+
+attribute vec4 vertex;
+attribute vec4 color;
+attribute vec2 texCoord;
+
+varying vec4 vertColor;
+varying vec4 vertTexCoord;
+
+void main() {
+  gl_Position = transform * vertex;
+    
+  vertColor = color;
+  vertTexCoord = texMatrix * vec4(texCoord, 1.0, 1.0);
+}