Michael Ludwig avatar Michael Ludwig committed 8d8ea0c

Improve JavaDoc and Java code formatting for IntelliJ

Comments (0)

Files changed (315)

 syntax: regexp
-\.project$
+^\.project$
 syntax: regexp
-\.settings$
+^\.classpath$
 syntax: regexp
-\.classpath$
+\.prefs$
 syntax: regexp
-/target$
+^\.settings$
 syntax: regexp
-\.DS_Store$
+^target$
+syntax: regexp
+^\.idea$
+syntax: regexp
+^.*\.iml$
+syntax: regexp
+^.DS_Store$

ferox-demos/pom.xml

-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <parent>
         <artifactId>ferox</artifactId>
     <artifactId>ferox-demos</artifactId>
     <packaging>jar</packaging>
     <name>Ferox Demo Applications</name>
-    
+
     <dependencies>
         <dependency>
             <groupId>com.lhkbob.ferox</groupId>

ferox-demos/src/main/java/com/ferox/anim/SimpleSkeletonDemo.java

 package com.ferox.anim;
 
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-
 import com.ferox.input.KeyEvent.KeyCode;
 import com.ferox.input.logic.Action;
 import com.ferox.input.logic.InputManager;
 import com.ferox.resource.geom.Cylinder;
 import com.ferox.resource.geom.Geometry;
 import com.ferox.resource.geom.Sphere;
-import com.ferox.scene.AmbientLight;
-import com.ferox.scene.BlinnPhongMaterial;
-import com.ferox.scene.Camera;
-import com.ferox.scene.DiffuseColor;
-import com.ferox.scene.PointLight;
-import com.ferox.scene.Renderable;
-import com.ferox.scene.Transform;
+import com.ferox.scene.*;
 import com.ferox.scene.task.BuildVisibilityIndexTask;
 import com.ferox.scene.task.ComputeCameraFrustumTask;
 import com.ferox.scene.task.ComputePVSTask;
 import com.lhkbob.entreri.task.Job;
 import com.lhkbob.entreri.task.Timers;
 
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
 public class SimpleSkeletonDemo extends ApplicationStub {
     // positive half-circle
     private static final double MAX_THETA = Math.PI;
         //        surface.setVSyncEnabled(true);
         system = new EntitySystem();
 
-        renderJob = system.getScheduler()
-                          .createJob("render",
-                                     Timers.measuredDelta(),
-                                     new SkeletonAnimationTask(),
-                                     new BoneTransformTask(),
-                                     new BoneLinkTask(),
-                                     new UpdateWorldBoundsTask(),
-                                     new ComputeCameraFrustumTask(),
-                                     new ComputeShadowFrustumTask(),
-                                     new BuildVisibilityIndexTask(new QuadTree<Entity>()),
-                                     new ComputePVSTask(),
-                                     new ComputeLightGroupTask(),
-                                     new FixedFunctionRenderTask(surface.getFramework(),
-                                                                 1024,
-                                                                 false));
+        renderJob = system.getScheduler().createJob("render", Timers.measuredDelta(),
+                                                    new SkeletonAnimationTask(),
+                                                    new BoneTransformTask(),
+                                                    new BoneLinkTask(),
+                                                    new UpdateWorldBoundsTask(),
+                                                    new ComputeCameraFrustumTask(),
+                                                    new ComputeShadowFrustumTask(),
+                                                    new BuildVisibilityIndexTask(
+                                                            new QuadTree<Entity>()),
+                                                    new ComputePVSTask(),
+                                                    new ComputeLightGroupTask(),
+                                                    new FixedFunctionRenderTask(
+                                                            surface.getFramework(), 1024,
+                                                            false));
 
         Entity mainSkeleton = system.addEntity();
         try {
             AcclaimSkeleton skeleton = new AcclaimSkeleton();
-            InputStream in = new FileInputStream("/Users/michaelludwig/Desktop/U of M/Semesters/Spring 2013/Directed Study/cmu_motions/35.asf");
+            InputStream in = new FileInputStream(
+                    "/Users/michaelludwig/Desktop/U of M/Semesters/Spring 2013/Directed Study/cmu_motions/35.asf");
             skeleton.load(in);
             skeleton.addSkeleton(mainSkeleton);
 
             in.close();
 
-            in = new FileInputStream("/Users/michaelludwig/Desktop/U of M/Semesters/Spring 2013/Directed Study/cmu_motions/35_22.amc");
+            in = new FileInputStream(
+                    "/Users/michaelludwig/Desktop/U of M/Semesters/Spring 2013/Directed Study/cmu_motions/35_22.amc");
             SkeletonAnimation anim = skeleton.loadAnimation(in, 1 / 120.0);
 
             mainSkeleton.add(Animated.class).getData().setAnimation(anim).setTimeScale(1);
             Geometry g = Cylinder.create(offset, offset, .1, offset.length() * 2, 16,
                                          StorageMode.GPU_STATIC);
 
-            boneLink.add(Renderable.class)
-                    .getData()
-                    .setVertices(g.getVertices())
+            boneLink.add(Renderable.class).getData().setVertices(g.getVertices())
                     .setIndices(g.getPolygonType(), g.getIndices(), g.getIndexOffset(),
                                 g.getIndexCount()).setLocalBounds(g.getBounds());
 
 
             g = Sphere.create(.3, 16, StorageMode.GPU_STATIC);
 
-            boneLink.add(Renderable.class)
-                    .getData()
-                    .setVertices(g.getVertices())
+            boneLink.add(Renderable.class).getData().setVertices(g.getVertices())
                     .setIndices(g.getPolygonType(), g.getIndices(), g.getIndexOffset(),
                                 g.getIndexCount()).setLocalBounds(g.getBounds());
 
         // a point light
         Entity point = system.addEntity();
         point.add(PointLight.class).getData().setColor(new ColorRGB(1, 1, 1));
-        point.get(Transform.class)
-             .getData()
-             .setMatrix(new Matrix4().setIdentity().setCol(3, new Vector4(10, 10, 10, 1)));
+        point.get(Transform.class).getData().setMatrix(
+                new Matrix4().setIdentity().setCol(3, new Vector4(10, 10, 10, 1)));
 
         Entity ambient = system.addEntity();
         ambient.add(AmbientLight.class).getData().setColor(new ColorRGB(.7, .7, .7));

ferox-demos/src/main/java/com/ferox/physics/GravityTest.java

 import com.ferox.renderer.OnscreenSurface;
 import com.ferox.resource.VertexBufferObject.StorageMode;
 import com.ferox.resource.geom.Geometry;
-import com.ferox.scene.AmbientLight;
-import com.ferox.scene.BlinnPhongMaterial;
-import com.ferox.scene.Camera;
-import com.ferox.scene.DiffuseColor;
-import com.ferox.scene.PointLight;
-import com.ferox.scene.Renderable;
-import com.ferox.scene.Transform;
+import com.ferox.scene.*;
 import com.lhkbob.entreri.Entity;
 
 public class GravityTest extends PhysicsApplicationStub {
         Entity camera = system.addEntity();
         camera.add(Camera.class).getData().setSurface(surface)
               .setZDistances(1.0, 6 * BOUNDS);
-        camera.add(Transform.class)
-              .getData()
-              .setMatrix(new Matrix4().set(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1,
-                                           .75 * BOUNDS, 0, 0, 0, 1));
+        camera.add(Transform.class).getData().setMatrix(new Matrix4()
+                                                                .set(-1, 0, 0, 0, 0, 1, 0,
+                                                                     0, 0, 0, -1,
+                                                                     .75 * BOUNDS, 0, 0,
+                                                                     0, 1));
 
         // shapes
-        Geometry geomShape1 = com.ferox.resource.geom.Box.create(2 + 2 * MARGIN, COMPILE_TYPE);
-        com.ferox.physics.collision.Shape physShape1 = new com.ferox.physics.collision.shape.Box(2,
-                                                                                                 2,
-                                                                                                 2);
+        Geometry geomShape1 = com.ferox.resource.geom.Box.create(2 + 2 * MARGIN,
+                                                                 COMPILE_TYPE);
+        com.ferox.physics.collision.Shape physShape1 = new com.ferox.physics.collision.shape.Box(
+                2, 2, 2);
 
-        Geometry geomShape2 = com.ferox.resource.geom.Box.create(2 + 2 * MARGIN, COMPILE_TYPE);
-        com.ferox.physics.collision.Shape physShape2 = new com.ferox.physics.collision.shape.Box(2,
-                                                                                                 2,
-                                                                                                 2);
+        Geometry geomShape2 = com.ferox.resource.geom.Box.create(2 + 2 * MARGIN,
+                                                                 COMPILE_TYPE);
+        com.ferox.physics.collision.Shape physShape2 = new com.ferox.physics.collision.shape.Box(
+                2, 2, 2);
 
         //        Geometry geomShape1 = new com.ferox.util.geom.Sphere(1 + MARGIN, 16, COMPILE_TYPE);
         //        com.ferox.physics.collision.Shape physShape1 = new com.ferox.physics.collision.shape.Sphere(1);
 
         // falling down entity
         Entity e = system.addEntity();
-        e.add(Renderable.class)
-         .getData()
-         .setVertices(geomShape1.getVertices())
+        e.add(Renderable.class).getData().setVertices(geomShape1.getVertices())
          .setLocalBounds(geomShape1.getBounds())
          .setIndices(geomShape1.getPolygonType(), geomShape1.getIndices(),
                      geomShape1.getIndexOffset(), geomShape1.getIndexCount());
         e.add(DiffuseColor.class).getData().setColor(new ColorRGB(1.0, 0.0, 0.0));
         e.add(Transform.class);
 
-        e.add(CollisionBody.class)
-         .getData()
-         .setShape(physShape1)
-         .setTransform(new Matrix4().set(1, 0, 0, 0, 0, 1, 0, BOUNDS / 2, 0, 0, 1, 0, 0,
-                                         0, 0, 1));
+        e.add(CollisionBody.class).getData().setShape(physShape1).setTransform(
+                new Matrix4()
+                        .set(1, 0, 0, 0, 0, 1, 0, BOUNDS / 2, 0, 0, 1, 0, 0, 0, 0, 1));
         e.add(RigidBody.class).getData().setMass(1.0);
         e.add(Gravity.class).getData().setGravity(new Vector3(0, -10, 0));
 
         // falling up entity
         e = system.addEntity();
-        e.add(Renderable.class)
-         .getData()
-         .setVertices(geomShape2.getVertices())
+        e.add(Renderable.class).getData().setVertices(geomShape2.getVertices())
          .setLocalBounds(geomShape2.getBounds())
          .setIndices(geomShape2.getPolygonType(), geomShape2.getIndices(),
                      geomShape2.getIndexOffset(), geomShape2.getIndexCount());
         e.add(DiffuseColor.class).getData().setColor(new ColorRGB(0.0, 1.0, 0.0));
         e.add(Transform.class);
 
-        e.add(CollisionBody.class)
-         .getData()
-         .setShape(physShape2)
-         .setTransform(new Matrix4().set(1, 0, 0, 0, 0, 1, 0, -BOUNDS / 2, 0, 0, 1, 0, 0,
-                                         0, 0, 1));
+        e.add(CollisionBody.class).getData().setShape(physShape2).setTransform(
+                new Matrix4()
+                        .set(1, 0, 0, 0, 0, 1, 0, -BOUNDS / 2, 0, 0, 1, 0, 0, 0, 0, 1));
         e.add(RigidBody.class).getData().setMass(1.0);
         e.add(Gravity.class).getData().setGravity(new Vector3(0, 10, 0));
 
         // a point light
         Entity point = system.addEntity();
         point.add(PointLight.class).getData().setColor(new ColorRGB(0.5, 0.5, 0.5));
-        point.add(Transform.class)
-             .getData()
-             .setMatrix(new Matrix4().set(1, 0, 0, BOUNDS / 2, 0, 1, 0, BOUNDS / 2, 0, 0,
-                                          1, BOUNDS / 2, 0, 0, 0, 1));
+        point.add(Transform.class).getData().setMatrix(new Matrix4()
+                                                               .set(1, 0, 0, BOUNDS / 2,
+                                                                    0, 1, 0, BOUNDS / 2,
+                                                                    0, 0, 1, BOUNDS / 2,
+                                                                    0, 0, 0, 1));
     }
 
     public static void main(String[] args) throws Exception {

ferox-demos/src/main/java/com/ferox/physics/PhysicsApplicationStub.java

     protected static final int BOUNDS = 50;
     protected static final double MARGIN = .05;
 
-    protected static final AxisAlignedBox worldBounds = new AxisAlignedBox(new Vector3(-2 * BOUNDS - 1,
-                                                                                       -2 * BOUNDS - 1,
-                                                                                       -2 * BOUNDS - 1),
-                                                                           new Vector3(2 * BOUNDS + 1,
-                                                                                       2 * BOUNDS + 1,
-                                                                                       2 * BOUNDS + 1));
+    protected static final AxisAlignedBox worldBounds = new AxisAlignedBox(
+            new Vector3(-2 * BOUNDS - 1, -2 * BOUNDS - 1, -2 * BOUNDS - 1),
+            new Vector3(2 * BOUNDS + 1, 2 * BOUNDS + 1, 2 * BOUNDS + 1));
 
     // positive half-circle
     private static final double MAX_THETA = Math.PI;
     protected void init(OnscreenSurface surface) {
         // physics handling
         physicsJob = system.getScheduler()
-                           .createJob("physics",
-                                      Timers.fixedDelta(1 / 60.0),
+                           .createJob("physics", Timers.fixedDelta(1 / 60.0),
                                       new ForcesTask(),
                                       //                                      new SpatialIndexCollisionController(new QuadTree<Entity>(worldBounds,
                                       //                                                                                               6),
                                       //                                                                          new DefaultCollisionAlgorithmProvider()),
                                       //                                      new SingleAxisSAPCollisionController(new DefaultCollisionAlgorithmProvider()),
-                                      new TemporalSAPCollisionTask(new DefaultCollisionAlgorithmProvider()),
+                                      new TemporalSAPCollisionTask(
+                                              new DefaultCollisionAlgorithmProvider()),
                                       new ConstraintSolvingTask(), new MotionTask(),
                                       new TransformController());
 
         // rendering
-        renderJob = system.getScheduler()
-                          .createJob("render",
-                                     new UpdateWorldBoundsTask(),
-                                     new ComputeCameraFrustumTask(),
-                                     new ComputeShadowFrustumTask(),
-                                     new BuildVisibilityIndexTask(new QuadTree<Entity>(worldBounds,
-                                                                                       6)),
-                                     new ComputePVSTask(),
-                                     new ComputeLightGroupTask(),
-                                     new FixedFunctionRenderTask(surface.getFramework(),
-                                                                 1024,
-                                                                 false));
+        renderJob = system.getScheduler().createJob("render", new UpdateWorldBoundsTask(),
+                                                    new ComputeCameraFrustumTask(),
+                                                    new ComputeShadowFrustumTask(),
+                                                    new BuildVisibilityIndexTask(
+                                                            new QuadTree<Entity>(
+                                                                    worldBounds, 6)),
+                                                    new ComputePVSTask(),
+                                                    new ComputeLightGroupTask(),
+                                                    new FixedFunctionRenderTask(
+                                                            surface.getFramework(), 1024,
+                                                            false));
 
         surface.setVSyncEnabled(true);
 

ferox-demos/src/main/java/com/ferox/physics/PhysicsTest.java

 import com.ferox.resource.VertexBufferObject.StorageMode;
 import com.ferox.resource.geom.Box;
 import com.ferox.resource.geom.Geometry;
-import com.ferox.scene.AmbientLight;
-import com.ferox.scene.AtmosphericFog;
+import com.ferox.scene.*;
 import com.ferox.scene.AtmosphericFog.Falloff;
-import com.ferox.scene.BlinnPhongMaterial;
-import com.ferox.scene.DiffuseColor;
-import com.ferox.scene.DirectionLight;
-import com.ferox.scene.PointLight;
-import com.ferox.scene.Renderable;
-import com.ferox.scene.Transform;
 import com.lhkbob.entreri.Entity;
 
 public class PhysicsTest extends PhysicsApplicationStub {
         Geometry box = Box.create(2 + 2 * MARGIN, COMPILE_TYPE);
         //        Geometry sphere = Sphere.create(1 + MARGIN, 32, COMPILE_TYPE);
 
-        com.ferox.physics.collision.Shape boxShape = new com.ferox.physics.collision.shape.Box(2,
-                                                                                               2,
-                                                                                               2);
+        com.ferox.physics.collision.Shape boxShape = new com.ferox.physics.collision.shape.Box(
+                2, 2, 2);
         //        com.ferox.physics.collision.Shape sphereShape = new com.ferox.physics.collision.shape.Sphere(1);
         boxShape.setMargin(MARGIN);
         //        sphereShape.setMargin(MARGIN);
 
                     physShape = boxShape;
                     geomShape = box;
-                    color = new ColorRGB(x / (double) NUM_X,
-                                         y / (double) NUM_Y,
+                    color = new ColorRGB(x / (double) NUM_X, y / (double) NUM_Y,
                                          z / (double) NUM_Z);
 
                     double rx = (Math.random() * randXLim - randXLim / 2);
                     double rz = (Math.random() * randZLim - randZLim / 2);
 
                     Entity e = system.addEntity();
-                    e.add(Renderable.class)
-                     .getData()
-                     .setVertices(geomShape.getVertices())
+                    e.add(Renderable.class).getData().setVertices(geomShape.getVertices())
                      .setLocalBounds(geomShape.getBounds())
                      .setIndices(geomShape.getPolygonType(), geomShape.getIndices(),
                                  geomShape.getIndexOffset(), geomShape.getIndexCount());
                      .setNormals(geomShape.getNormals());
                     e.add(DiffuseColor.class).getData().setColor(color);
 
-                    e.add(CollisionBody.class)
-                     .getData()
-                     .setShape(physShape)
-                     .setTransform(new Matrix4().setIdentity()
-                                                .setCol(3,
-                                                        new Vector4((SCALE_X + 2 * MARGIN) * x + rx + startX,
-                                                                    (SCALE_Y + 2 * MARGIN) * y + ry + startY,
-                                                                    (SCALE_Z + 2 * MARGIN) * z + rz + startZ,
-                                                                    1)));
+                    e.add(CollisionBody.class).getData().setShape(physShape).setTransform(
+                            new Matrix4().setIdentity().setCol(3, new Vector4(
+                                    (SCALE_X + 2 * MARGIN) * x + rx + startX,
+                                    (SCALE_Y + 2 * MARGIN) * y + ry + startY,
+                                    (SCALE_Z + 2 * MARGIN) * z + rz + startZ, 1)));
                     e.add(RigidBody.class).getData().setMass(1.0);
                 }
             }
         }
 
         // some walls
-        Geometry bottomWall = Box.create(BOUNDS + 2 * MARGIN, 1, BOUNDS + 2 * MARGIN,
-                                         COMPILE_TYPE);
+        Geometry bottomWall = Box
+                .create(BOUNDS + 2 * MARGIN, 1, BOUNDS + 2 * MARGIN, COMPILE_TYPE);
         Entity wall = system.addEntity();
-        wall.add(Renderable.class)
-            .getData()
-            .setVertices(bottomWall.getVertices())
+        wall.add(Renderable.class).getData().setVertices(bottomWall.getVertices())
             .setLocalBounds(bottomWall.getBounds())
             .setIndices(bottomWall.getPolygonType(), bottomWall.getIndices(),
                         bottomWall.getIndexOffset(), bottomWall.getIndexCount());
         wall.add(BlinnPhongMaterial.class).getData().setNormals(bottomWall.getNormals());
         wall.add(DiffuseColor.class).getData().setColor(new ColorRGB(0.5, 0.5, 0.5));
 
-        wall.add(CollisionBody.class)
-            .getData()
+        wall.add(CollisionBody.class).getData()
             .setShape(new com.ferox.physics.collision.shape.Box(BOUNDS, 1, BOUNDS))
-            .setTransform(new Matrix4().setIdentity()
-                                       .setCol(3, new Vector4(0, -.5, 0, 1)));
+            .setTransform(
+                    new Matrix4().setIdentity().setCol(3, new Vector4(0, -.5, 0, 1)));
 
         // fog
         system.addEntity().add(AtmosphericFog.class).getData()
         // a point light
         Entity point = system.addEntity();
         point.add(PointLight.class).getData().setColor(new ColorRGB(0.5, 0.5, 0.5));
-        point.get(Transform.class)
-             .getData()
-             .setMatrix(new Matrix4().setIdentity().setCol(3,
-                                                           new Vector4(BOUNDS / 2,
-                                                                       BOUNDS / 2,
-                                                                       BOUNDS / 2,
-                                                                       1)));
+        point.get(Transform.class).getData().setMatrix(new Matrix4().setIdentity()
+                                                                    .setCol(3,
+                                                                            new Vector4(
+                                                                                    BOUNDS /
+                                                                                    2,
+                                                                                    BOUNDS /
+                                                                                    2,
+                                                                                    BOUNDS /
+                                                                                    2,
+                                                                                    1)));
 
         // a directed light, which casts shadows
         Entity inf = system.addEntity();
         inf.add(DirectionLight.class).getData().setColor(new ColorRGB(1, 1, 1))
            .setShadowCaster(true);
-        inf.get(Transform.class)
-           .getData()
-           .setMatrix(new Matrix4().lookAt(new Vector3(), new Vector3(15, 15, 15),
-                                           new Vector3(0, 1, 0)));
+        inf.get(Transform.class).getData().setMatrix(new Matrix4().lookAt(new Vector3(),
+                                                                          new Vector3(15,
+                                                                                      15,
+                                                                                      15),
+                                                                          new Vector3(0,
+                                                                                      1,
+                                                                                      0)));
     }
 
     public static void main(String[] args) {

ferox-demos/src/main/java/com/ferox/renderer/impl/jogl/FixedFunctionRenderTest.java

 import com.ferox.math.Vector3;
 import com.ferox.math.Vector4;
 import com.ferox.math.bounds.Frustum;
-import com.ferox.renderer.Context;
-import com.ferox.renderer.FixedFunctionRenderer;
+import com.ferox.renderer.*;
 import com.ferox.renderer.FixedFunctionRenderer.TexCoord;
 import com.ferox.renderer.FixedFunctionRenderer.TexCoordSource;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
 import com.ferox.renderer.Renderer.DrawStyle;
-import com.ferox.renderer.Surface;
-import com.ferox.renderer.Task;
 import com.ferox.resource.BufferData;
 import com.ferox.resource.Mipmap;
 import com.ferox.resource.Texture;
     }
 
     @Override
-    protected void installInputHandlers(InputManager io) {}
+    protected void installInputHandlers(InputManager io) {
+    }
 
     @Override
     protected void init(OnscreenSurface surface) {
 
             shape = Sphere.create(2f, 32, StorageMode.GPU_STATIC);
 
-            f = new Frustum(60f,
-                            surface.getWidth() / (float) surface.getHeight(),
-                            1f,
+            f = new Frustum(60f, surface.getWidth() / (float) surface.getHeight(), 1f,
                             100f);
             f.setOrientation(new Vector3(0f, 3f, 10f), new Vector3(0f, 0f, -1f),
                              new Vector3(0f, 1f, 0f));
                 }
             }
 
-            Mipmap data = new Mipmap(new BufferData(volumeBuffer),
-                                     width,
-                                     height,
-                                     depth,
+            Mipmap data = new Mipmap(new BufferData(volumeBuffer), width, height, depth,
                                      TextureFormat.RGBA);
             volume = new Texture(Target.T_3D, data);
             volume.setFilter(Filter.NEAREST);
                     System.out.println("Rendered count: " + rendered);
 
                     System.out.println("\nvertices status: " + surface.getFramework()
-                                                                      .getStatus(shape.getVertices()
-                                                                                      .getVBO()));
+                                                                      .getStatus(
+                                                                              shape.getVertices()
+                                                                                   .getVBO()));
                     System.out.println("\nnormals status: " + surface.getFramework()
-                                                                     .getStatus(shape.getNormals()
-                                                                                     .getVBO()));
+                                                                     .getStatus(
+                                                                             shape.getNormals()
+                                                                                  .getVBO()));
                     System.out.println("\ntexcoords status: " + surface.getFramework()
-                                                                       .getStatus(shape.getTextureCoordinates()
-                                                                                       .getVBO()));
+                                                                       .getStatus(
+                                                                               shape.getTextureCoordinates()
+                                                                                    .getVBO()));
 
-                    System.out.println("\ntexture status: " + surface.getFramework()
-                                                                     .getStatus(volume) + " " + surface.getFramework()
-                                                                                                       .getStatusMessage(volume));
+                    System.out.println("\ntexture status: " +
+                                       surface.getFramework().getStatus(volume) + " " +
+                                       surface.getFramework().getStatusMessage(volume));
                 }
             }
 

ferox-demos/src/main/java/com/ferox/renderer/impl/jogl/GlslRenderTest.java

  */
 package com.ferox.renderer.impl.jogl;
 
-import java.util.Map;
-import java.util.Map.Entry;
-
 import com.ferox.input.logic.InputManager;
 import com.ferox.math.Vector3;
 import com.ferox.math.Vector4;
 import com.ferox.math.bounds.Frustum;
-import com.ferox.renderer.Context;
-import com.ferox.renderer.Framework;
-import com.ferox.renderer.GlslRenderer;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
-import com.ferox.renderer.Surface;
-import com.ferox.renderer.Task;
-import com.ferox.resource.BufferData;
-import com.ferox.resource.GlslShader;
+import com.ferox.renderer.*;
+import com.ferox.resource.*;
 import com.ferox.resource.GlslShader.ShaderType;
-import com.ferox.resource.GlslUniform;
-import com.ferox.resource.Mipmap;
 import com.ferox.resource.Resource.Status;
-import com.ferox.resource.Texture;
 import com.ferox.resource.Texture.Filter;
 import com.ferox.resource.Texture.Target;
 import com.ferox.resource.geom.Box;
 import com.ferox.resource.geom.Geometry;
-import com.ferox.resource.TextureFormat;
 import com.ferox.util.ApplicationStub;
 
+import java.util.Map;
+import java.util.Map.Entry;
+
 public class GlslRenderTest extends ApplicationStub {
-    private static final String VERTEX_SHADER = "uniform mat4 projection;" + "uniform mat4 modelview;" + "uniform vec2 transform;" +
+    private static final String VERTEX_SHADER =
+            "uniform mat4 projection;" + "uniform mat4 modelview;" +
+            "uniform vec2 transform;" +
 
-    "attribute vec3 vertex;" + "varying vec3 tcs;" +
+            "attribute vec3 vertex;" + "varying vec3 tcs;" +
 
-    "void main() {" + "   tcs = vec3((vertex.x + transform.x) * transform.y, (vertex.y + transform.x) * transform.y, (vertex.z + transform.x) * transform.y);" + "   gl_Position = projection * modelview * vec4(vertex, 1.0);" + "}";
-    private static final String FRAGMENT_SHADER = "uniform vec4 color;" + "uniform sampler3D texture;" +
+            "void main() {" +
+            "   tcs = vec3((vertex.x + transform.x) * transform.y, (vertex.y + transform.x) * transform.y, (vertex.z + transform.x) * transform.y);" +
+            "   gl_Position = projection * modelview * vec4(vertex, 1.0);" + "}";
+    private static final String FRAGMENT_SHADER =
+            "uniform vec4 color;" + "uniform sampler3D texture;" +
 
-    "varying vec3 tcs;" +
+            "varying vec3 tcs;" +
 
-    "void main() {" + "   gl_FragColor = texture3D(texture, tcs) * color;" + "}";
+            "void main() {" + "   gl_FragColor = texture3D(texture, tcs) * color;" + "}";
 
     private GlslPass pass;
 
     }
 
     @Override
-    protected void installInputHandlers(InputManager io) {}
+    protected void installInputHandlers(InputManager io) {
+    }
 
     @Override
     protected void init(OnscreenSurface surface) {
         pass = new GlslPass(surface);
         Status status = framework.update(pass.shader);
         if (status != Status.READY) {
-            System.out.println("Shader: " + status + " " + framework.getStatusMessage(pass.shader));
+            System.out.println(
+                    "Shader: " + status + " " + framework.getStatusMessage(pass.shader));
             framework.destroy();
             System.exit(0);
         }
             shader.setShader(ShaderType.VERTEX, VERTEX_SHADER);
             shader.setShader(ShaderType.FRAGMENT, FRAGMENT_SHADER);
 
-            f = new Frustum(60f,
-                            surface.getWidth() / (float) surface.getHeight(),
-                            1f,
+            f = new Frustum(60f, surface.getWidth() / (float) surface.getHeight(), 1f,
                             100f);
             f.setOrientation(new Vector3(0f, 3f, 10f), new Vector3(0f, 0f, -1f),
                              new Vector3(0f, 1f, 0f));
                 }
             }
 
-            Mipmap data = new Mipmap(new BufferData(volumeBuffer),
-                                     width,
-                                     height,
-                                     depth,
+            Mipmap data = new Mipmap(new BufferData(volumeBuffer), width, height, depth,
                                      TextureFormat.RGBA);
             volume = new Texture(Target.T_3D, data);
             volume.setFilter(Filter.NEAREST);
                     Map<String, GlslUniform> uniforms = g.getUniforms();
                     for (Entry<String, GlslUniform> u : uniforms.entrySet()) {
                         GlslUniform uniform = u.getValue();
-                        System.out.println(uniform.getName() + " " + uniform.getType() + " " + uniform.getLength());
+                        System.out
+                              .println(uniform.getName() + " " + uniform.getType() + " " +
+                                       uniform.getLength());
                     }
 
                     System.out.println("\nattributes:");
                     System.out.println(g.getAttributes());
 
-                    System.out.println("\ntexture status: " + surface.getFramework()
-                                                                     .getStatus(volume) + " " + surface.getFramework()
-                                                                                                       .getStatusMessage(volume));
+                    System.out.println("\ntexture status: " +
+                                       surface.getFramework().getStatus(volume) + " " +
+                                       surface.getFramework().getStatusMessage(volume));
                 }
             }
 

ferox-demos/src/main/java/com/ferox/renderer/impl/jogl/SelfDestructTest.java

  */
 package com.ferox.renderer.impl.jogl;
 
-import com.ferox.renderer.Framework;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
-import com.ferox.renderer.OnscreenSurfaceOptions;
-import com.ferox.renderer.Task;
+import com.ferox.renderer.*;
 
 public class SelfDestructTest {
     public static void main(String[] args) throws Exception {
         final Framework f = JoglFramework.create();
         System.out.println("framework created");
         final OnscreenSurface surface = f.createSurface(new OnscreenSurfaceOptions()
-        //            .setFullscreenMode(new DisplayMode(1024, 768, PixelFormat.RGB_24BIT))
-        .setUndecorated(true).setResizable(false).setWidth(500).setHeight(500));
+                                                                //            .setFullscreenMode(new DisplayMode(1024, 768, PixelFormat.RGB_24BIT))
+                                                                .setUndecorated(true)
+                                                                .setResizable(false)
+                                                                .setWidth(500)
+                                                                .setHeight(500));
 
         System.out.println("surface created");
         Thread.sleep(5000);

ferox-demos/src/main/java/com/ferox/renderer/impl/lwjgl/FixedFunctionRenderTest.java

 import com.ferox.math.Vector3;
 import com.ferox.math.Vector4;
 import com.ferox.math.bounds.Frustum;
-import com.ferox.renderer.Context;
-import com.ferox.renderer.FixedFunctionRenderer;
+import com.ferox.renderer.*;
 import com.ferox.renderer.FixedFunctionRenderer.TexCoord;
 import com.ferox.renderer.FixedFunctionRenderer.TexCoordSource;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
 import com.ferox.renderer.Renderer.DrawStyle;
-import com.ferox.renderer.Surface;
-import com.ferox.renderer.Task;
 import com.ferox.resource.BufferData;
 import com.ferox.resource.Mipmap;
 import com.ferox.resource.Texture;
     }
 
     @Override
-    protected void installInputHandlers(InputManager io) {}
+    protected void installInputHandlers(InputManager io) {
+    }
 
     @Override
     protected void init(OnscreenSurface surface) {
 
             shape = Sphere.create(2f, 32, StorageMode.GPU_STATIC);
 
-            f = new Frustum(60f,
-                            surface.getWidth() / (float) surface.getHeight(),
-                            1f,
+            f = new Frustum(60f, surface.getWidth() / (float) surface.getHeight(), 1f,
                             100f);
             f.setOrientation(new Vector3(0f, 3f, 10f), new Vector3(0f, 0f, -1f),
                              new Vector3(0f, 1f, 0f));
                 }
             }
 
-            Mipmap data = new Mipmap(new BufferData(volumeBuffer),
-                                     width,
-                                     height,
-                                     depth,
+            Mipmap data = new Mipmap(new BufferData(volumeBuffer), width, height, depth,
                                      TextureFormat.RGBA);
             volume = new Texture(Target.T_3D, data);
             volume.setFilter(Filter.NEAREST);
                     System.out.println("Rendered count: " + rendered);
 
                     System.out.println("\nvertices status: " + surface.getFramework()
-                                                                      .getStatus(shape.getVertices()
-                                                                                      .getVBO()));
+                                                                      .getStatus(
+                                                                              shape.getVertices()
+                                                                                   .getVBO()));
                     System.out.println("\nnormals status: " + surface.getFramework()
-                                                                     .getStatus(shape.getNormals()
-                                                                                     .getVBO()));
+                                                                     .getStatus(
+                                                                             shape.getNormals()
+                                                                                  .getVBO()));
                     System.out.println("\ntexcoords status: " + surface.getFramework()
-                                                                       .getStatus(shape.getTextureCoordinates()
-                                                                                       .getVBO()));
+                                                                       .getStatus(
+                                                                               shape.getTextureCoordinates()
+                                                                                    .getVBO()));
 
-                    System.out.println("\ntexture status: " + surface.getFramework()
-                                                                     .getStatus(volume) + " " + surface.getFramework()
-                                                                                                       .getStatusMessage(volume));
+                    System.out.println("\ntexture status: " +
+                                       surface.getFramework().getStatus(volume) + " " +
+                                       surface.getFramework().getStatusMessage(volume));
                 }
             }
 

ferox-demos/src/main/java/com/ferox/renderer/impl/lwjgl/GlslRenderTest.java

  */
 package com.ferox.renderer.impl.lwjgl;
 
-import java.util.Map;
-import java.util.Map.Entry;
-
 import com.ferox.input.logic.InputManager;
 import com.ferox.math.Vector3;
 import com.ferox.math.Vector4;
 import com.ferox.math.bounds.Frustum;
-import com.ferox.renderer.Context;
-import com.ferox.renderer.Framework;
-import com.ferox.renderer.GlslRenderer;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
-import com.ferox.renderer.Surface;
-import com.ferox.renderer.Task;
-import com.ferox.resource.BufferData;
-import com.ferox.resource.GlslShader;
+import com.ferox.renderer.*;
+import com.ferox.resource.*;
 import com.ferox.resource.GlslShader.ShaderType;
-import com.ferox.resource.GlslUniform;
-import com.ferox.resource.Mipmap;
 import com.ferox.resource.Resource.Status;
-import com.ferox.resource.Texture;
 import com.ferox.resource.Texture.Filter;
 import com.ferox.resource.Texture.Target;
 import com.ferox.resource.geom.Box;
 import com.ferox.resource.geom.Geometry;
-import com.ferox.resource.TextureFormat;
 import com.ferox.util.ApplicationStub;
 
+import java.util.Map;
+import java.util.Map.Entry;
+
 public class GlslRenderTest extends ApplicationStub {
-    private static final String VERTEX_SHADER = "uniform mat4 projection;" + "uniform mat4 modelview;" + "uniform vec2 transform;" +
+    private static final String VERTEX_SHADER =
+            "uniform mat4 projection;" + "uniform mat4 modelview;" +
+            "uniform vec2 transform;" +
 
-    "attribute vec3 vertex;" + "varying vec3 tcs;" +
+            "attribute vec3 vertex;" + "varying vec3 tcs;" +
 
-    "void main() {" + "   tcs = vec3((vertex.x + transform.x) * transform.y, (vertex.y + transform.x) * transform.y, (vertex.z + transform.x) * transform.y);" + "   gl_Position = projection * modelview * vec4(vertex, 1.0);" + "}";
-    private static final String FRAGMENT_SHADER = "uniform vec4 color;" + "uniform sampler3D texture;" +
+            "void main() {" +
+            "   tcs = vec3((vertex.x + transform.x) * transform.y, (vertex.y + transform.x) * transform.y, (vertex.z + transform.x) * transform.y);" +
+            "   gl_Position = projection * modelview * vec4(vertex, 1.0);" + "}";
+    private static final String FRAGMENT_SHADER =
+            "uniform vec4 color;" + "uniform sampler3D texture;" +
 
-    "varying vec3 tcs;" +
+            "varying vec3 tcs;" +
 
-    "void main() {" + "   gl_FragColor = texture3D(texture, tcs) * color;" + "}";
+            "void main() {" + "   gl_FragColor = texture3D(texture, tcs) * color;" + "}";
 
     private GlslPass pass;
 
     }
 
     @Override
-    protected void installInputHandlers(InputManager io) {}
+    protected void installInputHandlers(InputManager io) {
+    }
 
     @Override
     protected void init(OnscreenSurface surface) {
         pass = new GlslPass(surface);
         Status status = framework.update(pass.shader);
         if (status != Status.READY) {
-            System.out.println("Shader: " + status + " " + framework.getStatusMessage(pass.shader));
+            System.out.println(
+                    "Shader: " + status + " " + framework.getStatusMessage(pass.shader));
             framework.destroy();
             System.exit(0);
         }
             shader.setShader(ShaderType.VERTEX, VERTEX_SHADER);
             shader.setShader(ShaderType.FRAGMENT, FRAGMENT_SHADER);
 
-            f = new Frustum(60f,
-                            surface.getWidth() / (float) surface.getHeight(),
-                            1f,
+            f = new Frustum(60f, surface.getWidth() / (float) surface.getHeight(), 1f,
                             100f);
             f.setOrientation(new Vector3(0f, 3f, 10f), new Vector3(0f, 0f, -1f),
                              new Vector3(0f, 1f, 0f));
                 }
             }
 
-            Mipmap data = new Mipmap(new BufferData(volumeBuffer),
-                                     width,
-                                     height,
-                                     depth,
+            Mipmap data = new Mipmap(new BufferData(volumeBuffer), width, height, depth,
                                      TextureFormat.RGBA);
             volume = new Texture(Target.T_3D, data);
             volume.setFilter(Filter.NEAREST);
                     Map<String, GlslUniform> uniforms = g.getUniforms();
                     for (Entry<String, GlslUniform> u : uniforms.entrySet()) {
                         GlslUniform uniform = u.getValue();
-                        System.out.println(uniform.getName() + " " + uniform.getType() + " " + uniform.getLength());
+                        System.out
+                              .println(uniform.getName() + " " + uniform.getType() + " " +
+                                       uniform.getLength());
                     }
 
                     System.out.println("\nattributes:");
                     System.out.println(g.getAttributes());
 
-                    System.out.println("\ntexture status: " + surface.getFramework()
-                                                                     .getStatus(volume) + " " + surface.getFramework()
-                                                                                                       .getStatusMessage(volume));
+                    System.out.println("\ntexture status: " +
+                                       surface.getFramework().getStatus(volume) + " " +
+                                       surface.getFramework().getStatusMessage(volume));
                 }
             }
 

ferox-demos/src/main/java/com/ferox/renderer/impl/lwjgl/LightBlendingTest.java

  */
 package com.ferox.renderer.impl.lwjgl;
 
-import java.util.concurrent.Future;
-
 import com.ferox.input.logic.InputManager;
 import com.ferox.math.Vector3;
 import com.ferox.math.Vector4;
 import com.ferox.math.bounds.Frustum;
-import com.ferox.renderer.Context;
-import com.ferox.renderer.FixedFunctionRenderer;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
+import com.ferox.renderer.*;
 import com.ferox.renderer.Renderer.BlendFactor;
 import com.ferox.renderer.Renderer.BlendFunction;
 import com.ferox.renderer.Renderer.Comparison;
-import com.ferox.renderer.Task;
 import com.ferox.resource.geom.Box;
 import com.ferox.resource.geom.Geometry;
 import com.ferox.util.ApplicationStub;
 
+import java.util.concurrent.Future;
+
 public class LightBlendingTest extends ApplicationStub {
     private Geometry shape;
     private Frustum frustum;
     }
 
     @Override
-    protected void installInputHandlers(InputManager io) {}
+    protected void installInputHandlers(InputManager io) {
+    }
 
     @Override
     protected void init(OnscreenSurface surface) {
         shape = Box.create(3.0);
-        frustum = new Frustum(60f,
-                              surface.getWidth() / (double) surface.getHeight(),
-                              .1,
+        frustum = new Frustum(60f, surface.getWidth() / (double) surface.getHeight(), .1,
                               100);
         frustum.setOrientation(new Vector3(0, 2, -5), new Vector3(0, 0, 1),
                                new Vector3(0, 1, 0));

ferox-demos/src/main/java/com/ferox/renderer/impl/lwjgl/SelfDestructTest.java

  */
 package com.ferox.renderer.impl.lwjgl;
 
-import com.ferox.renderer.DisplayMode;
+import com.ferox.renderer.*;
 import com.ferox.renderer.DisplayMode.PixelFormat;
-import com.ferox.renderer.Framework;
-import com.ferox.renderer.HardwareAccessLayer;
-import com.ferox.renderer.OnscreenSurface;
-import com.ferox.renderer.OnscreenSurfaceOptions;
-import com.ferox.renderer.Task;
 
 public class SelfDestructTest {
     public static void main(String[] args) throws Exception {
         final Framework f = LwjglFramework.create();
         System.out.println("framework created");
-        final OnscreenSurface surface = f.createSurface(new OnscreenSurfaceOptions().setFullscreenMode(new DisplayMode(1024,
-                                                                                                                       768,
-                                                                                                                       PixelFormat.RGB_24BIT))
-                                                                                    .setUndecorated(true)
-                                                                                    .setResizable(false)
-                                                                                    .setWidth(500)
-                                                                                    .setHeight(500));
+        final OnscreenSurface surface = f.createSurface(new OnscreenSurfaceOptions()
+                                                                .setFullscreenMode(
+                                                                        new DisplayMode(
+                                                                                1024, 768,
+                                                                                PixelFormat.RGB_24BIT))
+                                                                .setUndecorated(true)
+                                                                .setResizable(false)
+                                                                .setWidth(500)
+                                                                .setHeight(500));
 
         System.out.println("surface created");
         Thread.sleep(5000);

ferox-demos/src/main/java/com/ferox/scene/controller/ffp/SimpleTest.java

  */
 package com.ferox.scene.controller.ffp;
 
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Set;
-
-import com.ferox.math.AxisAlignedBox;
-import com.ferox.math.ColorRGB;
-import com.ferox.math.Const;
-import com.ferox.math.Matrix4;
-import com.ferox.math.Vector3;
+import com.ferox.math.*;
 import com.ferox.math.bounds.QuadTree;
 import com.ferox.math.entreri.Vector3Property;
 import com.ferox.math.entreri.Vector3Property.DefaultVector3;
 import com.ferox.resource.geom.Geometry;
 import com.ferox.resource.geom.Sphere;
 import com.ferox.resource.geom.Teapot;
-import com.ferox.scene.AmbientLight;
-import com.ferox.scene.BlinnPhongMaterial;
-import com.ferox.scene.Camera;
-import com.ferox.scene.DiffuseColor;
-import com.ferox.scene.DirectionLight;
-import com.ferox.scene.InfluenceRegion;
-import com.ferox.scene.PointLight;
-import com.ferox.scene.Renderable;
-import com.ferox.scene.Transform;
+import com.ferox.scene.*;
 import com.ferox.scene.task.BuildVisibilityIndexTask;
 import com.ferox.scene.task.ComputeCameraFrustumTask;
 import com.ferox.scene.task.ComputePVSTask;
 import com.lhkbob.entreri.Unmanaged;
 import com.lhkbob.entreri.property.DoubleProperty;
 import com.lhkbob.entreri.property.DoubleProperty.DefaultDouble;
-import com.lhkbob.entreri.task.ElapsedTimeResult;
-import com.lhkbob.entreri.task.Job;
-import com.lhkbob.entreri.task.ParallelAware;
-import com.lhkbob.entreri.task.Task;
-import com.lhkbob.entreri.task.Timers;
+import com.lhkbob.entreri.task.*;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
 
 public class SimpleTest {
     public static final boolean LWJGL = true;
 
     public static void main(String[] args) {
         Framework framework = (LWJGL ? LwjglFramework.create() : JoglFramework.create());
-        OnscreenSurface surface = framework.createSurface(new OnscreenSurfaceOptions().setWidth(800)
-                                                                                      .setHeight(600)
-                                                                                      .setFullscreenMode(new DisplayMode(1440,
-                                                                                                                         900,
-                                                                                                                         PixelFormat.RGB_24BIT))
-                                                                                      .setResizable(false));
+        OnscreenSurface surface = framework.createSurface(
+                new OnscreenSurfaceOptions().setWidth(800).setHeight(600)
+                                            .setFullscreenMode(new DisplayMode(1440, 900,
+                                                                               PixelFormat.RGB_24BIT))
+                                            .setResizable(false));
         //        surface.setVSyncEnabled(true);
 
         EntitySystem system = new EntitySystem();
 
         Entity camera = system.addEntity();
-        camera.add(Transform.class)
-              .getData()
-              .setMatrix(new Matrix4().set(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1,
-                                           .9 * BOUNDS, 0, 0, 0, 1));
+        camera.add(Transform.class).getData().setMatrix(new Matrix4()
+                                                                .set(-1, 0, 0, 0, 0, 1, 0,
+                                                                     0, 0, 0, -1,
+                                                                     .9 * BOUNDS, 0, 0, 0,
+                                                                     1));
         camera.add(Camera.class).getData().setSurface(surface).setZDistances(0.1, 1200)
               .setFieldOfView(75);
 
         Geometry b2 = Box.create(2f, StorageMode.GPU_STATIC);
         Geometry b3 = Teapot.create(1f, StorageMode.GPU_STATIC);
 
-        ColorRGB c1 = new ColorRGB(Math.random() + 0.2,
-                                   Math.random() + 0.2,
+        ColorRGB c1 = new ColorRGB(Math.random() + 0.2, Math.random() + 0.2,
                                    Math.random() + 0.2);
-        ColorRGB c2 = new ColorRGB(Math.random() + 0.2,
-                                   Math.random() + 0.2,
+        ColorRGB c2 = new ColorRGB(Math.random() + 0.2, Math.random() + 0.2,
                                    Math.random() + 0.2);
-        ColorRGB c3 = new ColorRGB(Math.random() + 0.2,
-                                   Math.random() + 0.2,
+        ColorRGB c3 = new ColorRGB(Math.random() + 0.2, Math.random() + 0.2,
                                    Math.random() + 0.2);
 
         int totalpolys = 0;
                              .getPolygonCount(b.getIndexCount() - b.getIndexOffset());
 
             Entity e = system.addEntity();
-            e.add(Renderable.class)
-             .getData()
-             .setVertices(b.getVertices())
+            e.add(Renderable.class).getData().setVertices(b.getVertices())
              .setLocalBounds(b.getBounds())
              .setIndices(b.getPolygonType(), b.getIndices(), b.getIndexOffset(),
                          b.getIndexCount());
             e.add(BlinnPhongMaterial.class).getData().setNormals(b.getNormals());
             //            }
             e.add(DiffuseColor.class).getData().setColor(c);
-            e.add(Transform.class)
-             .getData()
-             .setMatrix(new Matrix4().set(1, 0, 0, Math.random() * BOUNDS - BOUNDS / 2,
-                                          0, 1, 0, Math.random() * BOUNDS - BOUNDS / 2,
-                                          0, 0, 1, Math.random() * BOUNDS - BOUNDS / 2,
-                                          0, 0, 0, 1));
+            e.add(Transform.class).getData().setMatrix(new Matrix4().set(1, 0, 0,
+                                                                         Math.random() *
+                                                                         BOUNDS -
+                                                                         BOUNDS / 2, 0, 1,
+                                                                         0,
+                                                                         Math.random() *
+                                                                         BOUNDS -
+                                                                         BOUNDS / 2, 0, 0,
+                                                                         1,
+                                                                         Math.random() *
+                                                                         BOUNDS -
+                                                                         BOUNDS / 2, 0, 0,
+                                                                         0, 1));
             e.add(Animation.class);
             totalpolys += polycount;
         }
                  .setColor(new ColorRGB(Math.random(), Math.random(), Math.random()));
 
             if (falloff > 0) {
-                light.add(InfluenceRegion.class)
-                     .getData()
-                     .setBounds(new AxisAlignedBox(new Vector3(-falloff,
-                                                               -falloff,
-                                                               -falloff),
-                                                   new Vector3(falloff, falloff, falloff)));
+                light.add(InfluenceRegion.class).getData().setBounds(
+                        new AxisAlignedBox(new Vector3(-falloff, -falloff, -falloff),
+                                           new Vector3(falloff, falloff, falloff)));
             }
-            light.add(Transform.class)
-                 .getData()
-                 .setMatrix(new Matrix4().set(1, 0, 0,
-                                              Math.random() * BOUNDS - BOUNDS / 2, 0, 1,
-                                              0, Math.random() * BOUNDS - BOUNDS / 2, 0,
-                                              0, 1, Math.random() * BOUNDS - BOUNDS / 2,
-                                              0, 0, 0, 1));
+            light.add(Transform.class).getData().setMatrix(new Matrix4().set(1, 0, 0,
+                                                                             Math.random() *
+                                                                             BOUNDS -
+                                                                             BOUNDS / 2,
+                                                                             0, 1, 0,
+                                                                             Math.random() *
+                                                                             BOUNDS -
+                                                                             BOUNDS / 2,
+                                                                             0, 0, 1,
+                                                                             Math.random() *
+                                                                             BOUNDS -
+                                                                             BOUNDS / 2,
+                                                                             0, 0, 0, 1));
         }
         system.addEntity().add(AmbientLight.class).getData()
               .setColor(new ColorRGB(0.2, 0.2, 0.2));
         Entity inf = system.addEntity();
         inf.add(DirectionLight.class).getData().setColor(new ColorRGB(1, 1, 1))
            .setShadowCaster(false);
-        inf.add(Transform.class)
-           .getData()
-           .setMatrix(new Matrix4().lookAt(new Vector3(), new Vector3(.3 * BOUNDS,
-                                                                      .3 * BOUNDS,
-                                                                      .3 * BOUNDS),
-                                           new Vector3(0, 1, 0)));
+        inf.add(Transform.class).getData().setMatrix(new Matrix4().lookAt(new Vector3(),
+                                                                          new Vector3(.3 *
+                                                                                      BOUNDS,
+                                                                                      .3 *
+                                                                                      BOUNDS,
+                                                                                      .3 *
+                                                                                      BOUNDS),
+                                                                          new Vector3(0,
+                                                                                      1,
+                                                                                      0)));
 
-        AxisAlignedBox worldBounds = new AxisAlignedBox(new Vector3(-1.5 * BOUNDS / 2,
-                                                                    -1.5 * BOUNDS / 2,
-                                                                    -1.5 * BOUNDS / 2),
-                                                        new Vector3(1.5 * BOUNDS / 2,
-                                                                    1.5 * BOUNDS / 2,
-                                                                    1.5 * BOUNDS / 2));
+        AxisAlignedBox worldBounds = new AxisAlignedBox(
+                new Vector3(-1.5 * BOUNDS / 2, -1.5 * BOUNDS / 2, -1.5 * BOUNDS / 2),
+                new Vector3(1.5 * BOUNDS / 2, 1.5 * BOUNDS / 2, 1.5 * BOUNDS / 2));
 
-        Job renderJob = system.getScheduler()
-                              .createJob("render",
-                                         Timers.measuredDelta(),
-                                         new AnimationController(),
-                                         new UpdateWorldBoundsTask(),
-                                         new ComputeCameraFrustumTask(),
-                                         new ComputeShadowFrustumTask(),
-                                         new BuildVisibilityIndexTask(new QuadTree<Entity>(worldBounds,
-                                                                                           6)),
-                                         new ComputePVSTask(),
-                                         new ComputeLightGroupTask(),
-                                         new FixedFunctionRenderTask(framework,
-                                                                     1024,
-                                                                     false));
+        Job renderJob = system.getScheduler().createJob("render", Timers.measuredDelta(),
+                                                        new AnimationController(),
+                                                        new UpdateWorldBoundsTask(),
+                                                        new ComputeCameraFrustumTask(),
+                                                        new ComputeShadowFrustumTask(),
+                                                        new BuildVisibilityIndexTask(
+                                                                new QuadTree<Entity>(
+                                                                        worldBounds, 6)),
+                                                        new ComputePVSTask(),
+                                                        new ComputeLightGroupTask(),
+                                                        new FixedFunctionRenderTask(
+                                                                framework, 1024, false));
 
         long now = System.nanoTime();
         int numRuns = 0;
         }
 
         @Override
-        public void reset(EntitySystem system) {}
+        public void reset(EntitySystem system) {
+        }
 
         @Override
         public Task process(EntitySystem system, Job job) {
                 Animation anim = it.next();
                 Vector3 d = anim.getDirection();
 
-                if (anim.getEntity().get(t) && anim.getDirection().lengthSquared() > 0.00001) {
+                if (anim.getEntity().get(t) &&
+                    anim.getDirection().lengthSquared() > 0.00001) {
                     // have a direction, assume its normalized
                     Matrix4 m = t.getMatrix();
 
         @Override
         @SuppressWarnings("unchecked")
         public Set<Class<? extends ComponentData<?>>> getAccessedComponents() {
-            return new HashSet<Class<? extends ComponentData<?>>>(Arrays.asList(Animation.class,
-                                                                                Transform.class));
+            return new HashSet<Class<? extends ComponentData<?>>>(
+                    Arrays.asList(Animation.class, Transform.class));
         }
 
         @Override
         @Unmanaged
         private final Vector3 cache = new Vector3();
 
-        private Animation() {}
+        private Animation() {
+        }
 
         public double getLifetime() {
             return life.get(getIndex());
             life.set(lt, getIndex());
         }
 
-        public @Const
+        public
+        @Const
         Vector3 getDirection() {
             return cache;
         }

ferox-demos/src/main/java/com/ferox/scene/controller/ffp/TransparentDemo.java

 import com.ferox.input.logic.InputManager;
 import com.ferox.input.logic.InputState;
 import com.ferox.input.logic.Predicates;
-import com.ferox.math.AxisAlignedBox;
-import com.ferox.math.ColorRGB;
-import com.ferox.math.Matrix4;
-import com.ferox.math.Vector3;
-import com.ferox.math.Vector4;
+import com.ferox.math.*;
 import com.ferox.math.bounds.QuadTree;
 import com.ferox.renderer.OnscreenSurface;
 import com.ferox.renderer.Renderer.DrawStyle;
 import com.ferox.renderer.impl.lwjgl.LwjglFramework;
 import com.ferox.resource.geom.Box;
 import com.ferox.resource.geom.Geometry;
-import com.ferox.scene.AmbientLight;
-import com.ferox.scene.BlinnPhongMaterial;
-import com.ferox.scene.Camera;
-import com.ferox.scene.DiffuseColor;
-import com.ferox.scene.DirectionLight;
-import com.ferox.scene.PointLight;
-import com.ferox.scene.Renderable;
-import com.ferox.scene.Transform;
-import com.ferox.scene.Transparent;
+import com.ferox.scene.*;