From 90fbf729755ba9e2bce668570aed9d54bb76de55 Mon Sep 17 00:00:00 2001
From: x <sketchpunk@gmail.com>
Date: Thu, 17 Jan 2019 03:47:27 -0500
Subject: [PATCH] New engine built up for fungi. Cleaning up old code into a
 folder for the time being.

---
 {fungi => _OLD}/Api.js                        |   0
 {fungi => _OLD}/App.js                        |   0
 {fungi/shaders => _OLD}/BaseColor.txt         |   0
 {fungi/primitives => _OLD}/Cone.js            |   0
 {fungi/primitives => _OLD}/Cylinder.js        |   0
 {fungi => _OLD}/Debug.js                      |   0
 {fungi => _OLD}/Ecs.js                        |   0
 {fungi => _OLD}/Fbo.js                        |   0
 {fungi => _OLD}/Fungi.js                      |   0
 {fungi/shaders => _OLD}/LowPolyPhong.txt      |   0
 {fungi => _OLD}/Maths.js                      |   0
 {fungi/shaders => _OLD}/PointCircle.txt       |   0
 {fungi/primitives => _OLD}/Quad.js            |   0
 {fungi => _OLD}/RenderLoop.js                 |   0
 {fungi => _OLD}/Shader.js                     |   0
 {fungi/shaders => _OLD}/TextureUV.txt         |   0
 {fungi/primitives => _OLD}/UVSphere.js        |   0
 {fungi => _OLD}/Ubo.js                        |   0
 {fungi => _OLD}/Vao.js                        |   0
 {fungi/primitives => _OLD}/Wedge.js           |   0
 {fungi => _OLD}/components/Behaviour.js       |   0
 {fungi => _OLD}/components/Camera.js          |   0
 {fungi => _OLD}/components/Drawable.js        |   0
 {fungi => _OLD}/components/DynamicVao.js      |   0
 {fungi => _OLD}/components/Hierarchy.js       |   0
 {fungi => _OLD}/components/Movement.js        |   0
 {fungi => _OLD}/components/Transform.js       |   0
 {fungi => _OLD}/components/TransformNode.js   |   0
 {fungi => _OLD}/data/DynamicBuffer.js         |   0
 {fungi => _OLD}/data/Geometry.js              |   0
 {fungi => _OLD}/data/Loader.js                |   0
 {fungi.mod => _OLD/fungi.mod}/Curves.js       |   0
 .../fungi.mod}/TestingMovement.js             |   0
 {fungi.mod => _OLD/fungi.mod}/Timing.js       |   0
 .../fungi.mod}/armature/Armature.js           |   0
 .../fungi.mod}/armature/ArmaturePreview.js    |   0
 .../fungi.mod}/armature/ArmatureSystem.js     |   0
 .../fungi.mod}/armature/Weights.js            |   0
 .../armature/shaders/ArmaturePreview.txt      |   0
 .../armature/shaders/ArmaturePreviewPhong.txt |   0
 .../armature/shaders/ArmaturePreviewScale.txt |   0
 .../armature/shaders/ArmatureSkin.txt         |   0
 .../armature/shaders/ArmatureSkinScale.txt    |   0
 .../fungi.mod}/armature_e/Armature.js         |   0
 .../fungi.mod}/armature_e/ArmaturePreview.js  |   0
 .../fungi.mod}/armature_e/ArmatureSystem.js   |   0
 .../fungi.mod}/armature_e/IKChain.js          |   0
 .../fungi.mod}/armature_e/IKChainAnimator.js  |   0
 .../fungi.mod}/armature_e/IKChainSolver.js    |   0
 .../fungi.mod}/armature_e/Weights.js          |   0
 .../armature_e/shaders/ArmaturePreview.txt    |   0
 .../shaders/ArmaturePreviewPhong.txt          |   0
 .../armature_e/shaders/ArmatureSkin.txt       |   0
 .../deferred/BasicDeferredRendering.js        |   0
 .../fungi.mod}/deferred/DeferredRendering.js  |   0
 .../fungi.mod}/deferred/DirectionalLight.js   |   0
 .../fungi.mod}/deferred/Frustum.js            |   0
 .../fungi.mod}/deferred/PostEffect_Blur.js    |   0
 .../fungi.mod}/deferred/ShadowMap.js          |   0
 .../fungi.mod}/deferred/shaders/FungiBlur.txt |   0
 .../deferred/shaders/LowPolyColor.txt         |   0
 .../deferred/shaders/PhongLighting.txt        |   0
 .../deferred/shaders/PhongLightingShadow.txt  |   0
 .../fungi.mod}/deferred/shaders/PostBasic.txt |   0
 .../fungi.mod}/deferred/shaders/VecWColor.txt |   0
 .../fungi.mod}/particles/ParticleModules.js   |   0
 .../fungi.mod}/particles/ParticleSystem.js    |   0
 .../fungi.mod}/particles/TransformFeedback.js |   0
 .../postEffects/shaders/PostBasic.txt         |   0
 .../postEffects/shaders/PostBasic2.txt        |   0
 .../fungi.mod}/raycast/BoundingCapsule.js     |   0
 .../fungi.mod}/raycast/BoundingSphere.js      |   0
 {fungi.mod => _OLD/fungi.mod}/raycast/Ray.js  |   0
 .../fungi.mod}/shaders/Grid001.txt            |   0
 .../fungi.mod}/shaders/Grid002.txt            |   0
 .../fungi.mod}/shaders/Grid003.txt            |   0
 .../fungi.mod}/terrain/DynamicChunk.js        |   0
 .../fungi.mod}/terrain/PatchNine.js           |   0
 .../fungi.mod}/terrain/Terrain_Grid.js        |   0
 .../fungi.mod}/terrain/Terrain_IsoGrid.js     |   0
 .../fungi.mod}/terrain/Terrain_old.js         |   0
 .../fungi.mod}/voxel/DynamicVoxelSystem.js    |   0
 {fungi.mod => _OLD/fungi.mod}/voxel/Voxel.js  |   0
 .../fungi.mod}/voxel/VoxelChunk.js            |   0
 .../fungi.mod}/voxel/VoxelDynamicVao.js       |   0
 .../fungi.mod}/voxel/VoxelRaycast.js          |   0
 {fungi => _OLD}/gl.js                         |   0
 {fungi => _OLD}/input/InputTracker.js         |   0
 {fungi => _OLD}/net/Downloader.js             |   0
 {fungi => _OLD}/systems/BehaviourSystem.js    |   0
 {fungi => _OLD}/systems/CameraSystem.js       |   0
 {fungi => _OLD}/systems/DynamicVaoSystem.js   |   0
 {fungi => _OLD}/systems/MovementSystem.js     |   0
 {fungi => _OLD}/systems/RenderSystem.js       |   0
 {fungi => _OLD}/systems/RightMouseSystem.js   |   0
 .../systems/TransformHierarchySystem.js       |   0
 .../systems/TransformNodeSystem.js            |   0
 {fungi => _OLD}/systems/TransformSystem.js    |   0
 ecs.txt                                       |  13 -
 fungi/engine/App.js                           |   3 +-
 fungi/engine/Debug.js                         |   2 +-
 fungi/engine/_test_page.html                  |  20 +-
 fungi/engine/ecs/DynamicVerts.js              |   2 +-
 fungi/engine/ecs/Node.js                      | 170 +++-
 fungi/engine/ecs/Transform.js                 |  36 -
 fungi/engine/ecs/TransformNode.js             | 190 -----
 fungi/maths/Axis.js                           | 160 ++--
 fungi/maths/DualQuat.js                       | 626 +++++++--------
 fungi/maths/Mat4.js                           | 726 +++++++++---------
 fungi/maths/Maths.js                          |   6 +-
 fungi/maths/Quat.js                           | 501 ++++++------
 fungi/maths/Vec3.js                           | 187 +++--
 Quat_Tips.txt => notes/Quat_Tips.txt          |   0
 code.txt => notes/code.txt                    |   7 +-
 notes/ecs.txt                                 |  85 ++
 extra.txt => notes/extra.txt                  |   0
 glsl.txt => notes/glsl.txt                    |   0
 ideas_to_try.txt => notes/ideas_to_try.txt    |   0
 notes/jsdoc.txt                               |  26 +
 math_notes.txt => notes/math_notes.txt        |   0
 misc_notes.txt => notes/misc_notes.txt        |   0
 notes/toon_and_rim_dir.txt                    | 140 ++++
 notes/transform.txt                           | 332 ++++++++
 123 files changed, 1909 insertions(+), 1323 deletions(-)
 rename {fungi => _OLD}/Api.js (100%)
 rename {fungi => _OLD}/App.js (100%)
 rename {fungi/shaders => _OLD}/BaseColor.txt (100%)
 rename {fungi/primitives => _OLD}/Cone.js (100%)
 rename {fungi/primitives => _OLD}/Cylinder.js (100%)
 rename {fungi => _OLD}/Debug.js (100%)
 rename {fungi => _OLD}/Ecs.js (100%)
 rename {fungi => _OLD}/Fbo.js (100%)
 rename {fungi => _OLD}/Fungi.js (100%)
 rename {fungi/shaders => _OLD}/LowPolyPhong.txt (100%)
 rename {fungi => _OLD}/Maths.js (100%)
 rename {fungi/shaders => _OLD}/PointCircle.txt (100%)
 rename {fungi/primitives => _OLD}/Quad.js (100%)
 rename {fungi => _OLD}/RenderLoop.js (100%)
 rename {fungi => _OLD}/Shader.js (100%)
 rename {fungi/shaders => _OLD}/TextureUV.txt (100%)
 rename {fungi/primitives => _OLD}/UVSphere.js (100%)
 rename {fungi => _OLD}/Ubo.js (100%)
 rename {fungi => _OLD}/Vao.js (100%)
 rename {fungi/primitives => _OLD}/Wedge.js (100%)
 rename {fungi => _OLD}/components/Behaviour.js (100%)
 rename {fungi => _OLD}/components/Camera.js (100%)
 rename {fungi => _OLD}/components/Drawable.js (100%)
 rename {fungi => _OLD}/components/DynamicVao.js (100%)
 rename {fungi => _OLD}/components/Hierarchy.js (100%)
 rename {fungi => _OLD}/components/Movement.js (100%)
 rename {fungi => _OLD}/components/Transform.js (100%)
 rename {fungi => _OLD}/components/TransformNode.js (100%)
 rename {fungi => _OLD}/data/DynamicBuffer.js (100%)
 rename {fungi => _OLD}/data/Geometry.js (100%)
 rename {fungi => _OLD}/data/Loader.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/Curves.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/TestingMovement.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/Timing.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/Armature.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/ArmaturePreview.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/ArmatureSystem.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/Weights.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/shaders/ArmaturePreview.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/shaders/ArmaturePreviewPhong.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/shaders/ArmaturePreviewScale.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/shaders/ArmatureSkin.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature/shaders/ArmatureSkinScale.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/Armature.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/ArmaturePreview.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/ArmatureSystem.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/IKChain.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/IKChainAnimator.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/IKChainSolver.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/Weights.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/shaders/ArmaturePreview.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/shaders/ArmaturePreviewPhong.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/armature_e/shaders/ArmatureSkin.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/BasicDeferredRendering.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/DeferredRendering.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/DirectionalLight.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/Frustum.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/PostEffect_Blur.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/ShadowMap.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/FungiBlur.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/LowPolyColor.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/PhongLighting.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/PhongLightingShadow.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/PostBasic.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/deferred/shaders/VecWColor.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/particles/ParticleModules.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/particles/ParticleSystem.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/particles/TransformFeedback.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/postEffects/shaders/PostBasic.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/postEffects/shaders/PostBasic2.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/raycast/BoundingCapsule.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/raycast/BoundingSphere.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/raycast/Ray.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/shaders/Grid001.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/shaders/Grid002.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/shaders/Grid003.txt (100%)
 rename {fungi.mod => _OLD/fungi.mod}/terrain/DynamicChunk.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/terrain/PatchNine.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/terrain/Terrain_Grid.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/terrain/Terrain_IsoGrid.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/terrain/Terrain_old.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/voxel/DynamicVoxelSystem.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/voxel/Voxel.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/voxel/VoxelChunk.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/voxel/VoxelDynamicVao.js (100%)
 rename {fungi.mod => _OLD/fungi.mod}/voxel/VoxelRaycast.js (100%)
 rename {fungi => _OLD}/gl.js (100%)
 rename {fungi => _OLD}/input/InputTracker.js (100%)
 rename {fungi => _OLD}/net/Downloader.js (100%)
 rename {fungi => _OLD}/systems/BehaviourSystem.js (100%)
 rename {fungi => _OLD}/systems/CameraSystem.js (100%)
 rename {fungi => _OLD}/systems/DynamicVaoSystem.js (100%)
 rename {fungi => _OLD}/systems/MovementSystem.js (100%)
 rename {fungi => _OLD}/systems/RenderSystem.js (100%)
 rename {fungi => _OLD}/systems/RightMouseSystem.js (100%)
 rename {fungi => _OLD}/systems/TransformHierarchySystem.js (100%)
 rename {fungi => _OLD}/systems/TransformNodeSystem.js (100%)
 rename {fungi => _OLD}/systems/TransformSystem.js (100%)
 delete mode 100644 ecs.txt
 delete mode 100644 fungi/engine/ecs/Transform.js
 delete mode 100644 fungi/engine/ecs/TransformNode.js
 rename Quat_Tips.txt => notes/Quat_Tips.txt (100%)
 rename code.txt => notes/code.txt (99%)
 create mode 100644 notes/ecs.txt
 rename extra.txt => notes/extra.txt (100%)
 rename glsl.txt => notes/glsl.txt (100%)
 rename ideas_to_try.txt => notes/ideas_to_try.txt (100%)
 create mode 100644 notes/jsdoc.txt
 rename math_notes.txt => notes/math_notes.txt (100%)
 rename misc_notes.txt => notes/misc_notes.txt (100%)
 create mode 100644 notes/toon_and_rim_dir.txt
 create mode 100644 notes/transform.txt

diff --git a/fungi/Api.js b/_OLD/Api.js
similarity index 100%
rename from fungi/Api.js
rename to _OLD/Api.js
diff --git a/fungi/App.js b/_OLD/App.js
similarity index 100%
rename from fungi/App.js
rename to _OLD/App.js
diff --git a/fungi/shaders/BaseColor.txt b/_OLD/BaseColor.txt
similarity index 100%
rename from fungi/shaders/BaseColor.txt
rename to _OLD/BaseColor.txt
diff --git a/fungi/primitives/Cone.js b/_OLD/Cone.js
similarity index 100%
rename from fungi/primitives/Cone.js
rename to _OLD/Cone.js
diff --git a/fungi/primitives/Cylinder.js b/_OLD/Cylinder.js
similarity index 100%
rename from fungi/primitives/Cylinder.js
rename to _OLD/Cylinder.js
diff --git a/fungi/Debug.js b/_OLD/Debug.js
similarity index 100%
rename from fungi/Debug.js
rename to _OLD/Debug.js
diff --git a/fungi/Ecs.js b/_OLD/Ecs.js
similarity index 100%
rename from fungi/Ecs.js
rename to _OLD/Ecs.js
diff --git a/fungi/Fbo.js b/_OLD/Fbo.js
similarity index 100%
rename from fungi/Fbo.js
rename to _OLD/Fbo.js
diff --git a/fungi/Fungi.js b/_OLD/Fungi.js
similarity index 100%
rename from fungi/Fungi.js
rename to _OLD/Fungi.js
diff --git a/fungi/shaders/LowPolyPhong.txt b/_OLD/LowPolyPhong.txt
similarity index 100%
rename from fungi/shaders/LowPolyPhong.txt
rename to _OLD/LowPolyPhong.txt
diff --git a/fungi/Maths.js b/_OLD/Maths.js
similarity index 100%
rename from fungi/Maths.js
rename to _OLD/Maths.js
diff --git a/fungi/shaders/PointCircle.txt b/_OLD/PointCircle.txt
similarity index 100%
rename from fungi/shaders/PointCircle.txt
rename to _OLD/PointCircle.txt
diff --git a/fungi/primitives/Quad.js b/_OLD/Quad.js
similarity index 100%
rename from fungi/primitives/Quad.js
rename to _OLD/Quad.js
diff --git a/fungi/RenderLoop.js b/_OLD/RenderLoop.js
similarity index 100%
rename from fungi/RenderLoop.js
rename to _OLD/RenderLoop.js
diff --git a/fungi/Shader.js b/_OLD/Shader.js
similarity index 100%
rename from fungi/Shader.js
rename to _OLD/Shader.js
diff --git a/fungi/shaders/TextureUV.txt b/_OLD/TextureUV.txt
similarity index 100%
rename from fungi/shaders/TextureUV.txt
rename to _OLD/TextureUV.txt
diff --git a/fungi/primitives/UVSphere.js b/_OLD/UVSphere.js
similarity index 100%
rename from fungi/primitives/UVSphere.js
rename to _OLD/UVSphere.js
diff --git a/fungi/Ubo.js b/_OLD/Ubo.js
similarity index 100%
rename from fungi/Ubo.js
rename to _OLD/Ubo.js
diff --git a/fungi/Vao.js b/_OLD/Vao.js
similarity index 100%
rename from fungi/Vao.js
rename to _OLD/Vao.js
diff --git a/fungi/primitives/Wedge.js b/_OLD/Wedge.js
similarity index 100%
rename from fungi/primitives/Wedge.js
rename to _OLD/Wedge.js
diff --git a/fungi/components/Behaviour.js b/_OLD/components/Behaviour.js
similarity index 100%
rename from fungi/components/Behaviour.js
rename to _OLD/components/Behaviour.js
diff --git a/fungi/components/Camera.js b/_OLD/components/Camera.js
similarity index 100%
rename from fungi/components/Camera.js
rename to _OLD/components/Camera.js
diff --git a/fungi/components/Drawable.js b/_OLD/components/Drawable.js
similarity index 100%
rename from fungi/components/Drawable.js
rename to _OLD/components/Drawable.js
diff --git a/fungi/components/DynamicVao.js b/_OLD/components/DynamicVao.js
similarity index 100%
rename from fungi/components/DynamicVao.js
rename to _OLD/components/DynamicVao.js
diff --git a/fungi/components/Hierarchy.js b/_OLD/components/Hierarchy.js
similarity index 100%
rename from fungi/components/Hierarchy.js
rename to _OLD/components/Hierarchy.js
diff --git a/fungi/components/Movement.js b/_OLD/components/Movement.js
similarity index 100%
rename from fungi/components/Movement.js
rename to _OLD/components/Movement.js
diff --git a/fungi/components/Transform.js b/_OLD/components/Transform.js
similarity index 100%
rename from fungi/components/Transform.js
rename to _OLD/components/Transform.js
diff --git a/fungi/components/TransformNode.js b/_OLD/components/TransformNode.js
similarity index 100%
rename from fungi/components/TransformNode.js
rename to _OLD/components/TransformNode.js
diff --git a/fungi/data/DynamicBuffer.js b/_OLD/data/DynamicBuffer.js
similarity index 100%
rename from fungi/data/DynamicBuffer.js
rename to _OLD/data/DynamicBuffer.js
diff --git a/fungi/data/Geometry.js b/_OLD/data/Geometry.js
similarity index 100%
rename from fungi/data/Geometry.js
rename to _OLD/data/Geometry.js
diff --git a/fungi/data/Loader.js b/_OLD/data/Loader.js
similarity index 100%
rename from fungi/data/Loader.js
rename to _OLD/data/Loader.js
diff --git a/fungi.mod/Curves.js b/_OLD/fungi.mod/Curves.js
similarity index 100%
rename from fungi.mod/Curves.js
rename to _OLD/fungi.mod/Curves.js
diff --git a/fungi.mod/TestingMovement.js b/_OLD/fungi.mod/TestingMovement.js
similarity index 100%
rename from fungi.mod/TestingMovement.js
rename to _OLD/fungi.mod/TestingMovement.js
diff --git a/fungi.mod/Timing.js b/_OLD/fungi.mod/Timing.js
similarity index 100%
rename from fungi.mod/Timing.js
rename to _OLD/fungi.mod/Timing.js
diff --git a/fungi.mod/armature/Armature.js b/_OLD/fungi.mod/armature/Armature.js
similarity index 100%
rename from fungi.mod/armature/Armature.js
rename to _OLD/fungi.mod/armature/Armature.js
diff --git a/fungi.mod/armature/ArmaturePreview.js b/_OLD/fungi.mod/armature/ArmaturePreview.js
similarity index 100%
rename from fungi.mod/armature/ArmaturePreview.js
rename to _OLD/fungi.mod/armature/ArmaturePreview.js
diff --git a/fungi.mod/armature/ArmatureSystem.js b/_OLD/fungi.mod/armature/ArmatureSystem.js
similarity index 100%
rename from fungi.mod/armature/ArmatureSystem.js
rename to _OLD/fungi.mod/armature/ArmatureSystem.js
diff --git a/fungi.mod/armature/Weights.js b/_OLD/fungi.mod/armature/Weights.js
similarity index 100%
rename from fungi.mod/armature/Weights.js
rename to _OLD/fungi.mod/armature/Weights.js
diff --git a/fungi.mod/armature/shaders/ArmaturePreview.txt b/_OLD/fungi.mod/armature/shaders/ArmaturePreview.txt
similarity index 100%
rename from fungi.mod/armature/shaders/ArmaturePreview.txt
rename to _OLD/fungi.mod/armature/shaders/ArmaturePreview.txt
diff --git a/fungi.mod/armature/shaders/ArmaturePreviewPhong.txt b/_OLD/fungi.mod/armature/shaders/ArmaturePreviewPhong.txt
similarity index 100%
rename from fungi.mod/armature/shaders/ArmaturePreviewPhong.txt
rename to _OLD/fungi.mod/armature/shaders/ArmaturePreviewPhong.txt
diff --git a/fungi.mod/armature/shaders/ArmaturePreviewScale.txt b/_OLD/fungi.mod/armature/shaders/ArmaturePreviewScale.txt
similarity index 100%
rename from fungi.mod/armature/shaders/ArmaturePreviewScale.txt
rename to _OLD/fungi.mod/armature/shaders/ArmaturePreviewScale.txt
diff --git a/fungi.mod/armature/shaders/ArmatureSkin.txt b/_OLD/fungi.mod/armature/shaders/ArmatureSkin.txt
similarity index 100%
rename from fungi.mod/armature/shaders/ArmatureSkin.txt
rename to _OLD/fungi.mod/armature/shaders/ArmatureSkin.txt
diff --git a/fungi.mod/armature/shaders/ArmatureSkinScale.txt b/_OLD/fungi.mod/armature/shaders/ArmatureSkinScale.txt
similarity index 100%
rename from fungi.mod/armature/shaders/ArmatureSkinScale.txt
rename to _OLD/fungi.mod/armature/shaders/ArmatureSkinScale.txt
diff --git a/fungi.mod/armature_e/Armature.js b/_OLD/fungi.mod/armature_e/Armature.js
similarity index 100%
rename from fungi.mod/armature_e/Armature.js
rename to _OLD/fungi.mod/armature_e/Armature.js
diff --git a/fungi.mod/armature_e/ArmaturePreview.js b/_OLD/fungi.mod/armature_e/ArmaturePreview.js
similarity index 100%
rename from fungi.mod/armature_e/ArmaturePreview.js
rename to _OLD/fungi.mod/armature_e/ArmaturePreview.js
diff --git a/fungi.mod/armature_e/ArmatureSystem.js b/_OLD/fungi.mod/armature_e/ArmatureSystem.js
similarity index 100%
rename from fungi.mod/armature_e/ArmatureSystem.js
rename to _OLD/fungi.mod/armature_e/ArmatureSystem.js
diff --git a/fungi.mod/armature_e/IKChain.js b/_OLD/fungi.mod/armature_e/IKChain.js
similarity index 100%
rename from fungi.mod/armature_e/IKChain.js
rename to _OLD/fungi.mod/armature_e/IKChain.js
diff --git a/fungi.mod/armature_e/IKChainAnimator.js b/_OLD/fungi.mod/armature_e/IKChainAnimator.js
similarity index 100%
rename from fungi.mod/armature_e/IKChainAnimator.js
rename to _OLD/fungi.mod/armature_e/IKChainAnimator.js
diff --git a/fungi.mod/armature_e/IKChainSolver.js b/_OLD/fungi.mod/armature_e/IKChainSolver.js
similarity index 100%
rename from fungi.mod/armature_e/IKChainSolver.js
rename to _OLD/fungi.mod/armature_e/IKChainSolver.js
diff --git a/fungi.mod/armature_e/Weights.js b/_OLD/fungi.mod/armature_e/Weights.js
similarity index 100%
rename from fungi.mod/armature_e/Weights.js
rename to _OLD/fungi.mod/armature_e/Weights.js
diff --git a/fungi.mod/armature_e/shaders/ArmaturePreview.txt b/_OLD/fungi.mod/armature_e/shaders/ArmaturePreview.txt
similarity index 100%
rename from fungi.mod/armature_e/shaders/ArmaturePreview.txt
rename to _OLD/fungi.mod/armature_e/shaders/ArmaturePreview.txt
diff --git a/fungi.mod/armature_e/shaders/ArmaturePreviewPhong.txt b/_OLD/fungi.mod/armature_e/shaders/ArmaturePreviewPhong.txt
similarity index 100%
rename from fungi.mod/armature_e/shaders/ArmaturePreviewPhong.txt
rename to _OLD/fungi.mod/armature_e/shaders/ArmaturePreviewPhong.txt
diff --git a/fungi.mod/armature_e/shaders/ArmatureSkin.txt b/_OLD/fungi.mod/armature_e/shaders/ArmatureSkin.txt
similarity index 100%
rename from fungi.mod/armature_e/shaders/ArmatureSkin.txt
rename to _OLD/fungi.mod/armature_e/shaders/ArmatureSkin.txt
diff --git a/fungi.mod/deferred/BasicDeferredRendering.js b/_OLD/fungi.mod/deferred/BasicDeferredRendering.js
similarity index 100%
rename from fungi.mod/deferred/BasicDeferredRendering.js
rename to _OLD/fungi.mod/deferred/BasicDeferredRendering.js
diff --git a/fungi.mod/deferred/DeferredRendering.js b/_OLD/fungi.mod/deferred/DeferredRendering.js
similarity index 100%
rename from fungi.mod/deferred/DeferredRendering.js
rename to _OLD/fungi.mod/deferred/DeferredRendering.js
diff --git a/fungi.mod/deferred/DirectionalLight.js b/_OLD/fungi.mod/deferred/DirectionalLight.js
similarity index 100%
rename from fungi.mod/deferred/DirectionalLight.js
rename to _OLD/fungi.mod/deferred/DirectionalLight.js
diff --git a/fungi.mod/deferred/Frustum.js b/_OLD/fungi.mod/deferred/Frustum.js
similarity index 100%
rename from fungi.mod/deferred/Frustum.js
rename to _OLD/fungi.mod/deferred/Frustum.js
diff --git a/fungi.mod/deferred/PostEffect_Blur.js b/_OLD/fungi.mod/deferred/PostEffect_Blur.js
similarity index 100%
rename from fungi.mod/deferred/PostEffect_Blur.js
rename to _OLD/fungi.mod/deferred/PostEffect_Blur.js
diff --git a/fungi.mod/deferred/ShadowMap.js b/_OLD/fungi.mod/deferred/ShadowMap.js
similarity index 100%
rename from fungi.mod/deferred/ShadowMap.js
rename to _OLD/fungi.mod/deferred/ShadowMap.js
diff --git a/fungi.mod/deferred/shaders/FungiBlur.txt b/_OLD/fungi.mod/deferred/shaders/FungiBlur.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/FungiBlur.txt
rename to _OLD/fungi.mod/deferred/shaders/FungiBlur.txt
diff --git a/fungi.mod/deferred/shaders/LowPolyColor.txt b/_OLD/fungi.mod/deferred/shaders/LowPolyColor.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/LowPolyColor.txt
rename to _OLD/fungi.mod/deferred/shaders/LowPolyColor.txt
diff --git a/fungi.mod/deferred/shaders/PhongLighting.txt b/_OLD/fungi.mod/deferred/shaders/PhongLighting.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/PhongLighting.txt
rename to _OLD/fungi.mod/deferred/shaders/PhongLighting.txt
diff --git a/fungi.mod/deferred/shaders/PhongLightingShadow.txt b/_OLD/fungi.mod/deferred/shaders/PhongLightingShadow.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/PhongLightingShadow.txt
rename to _OLD/fungi.mod/deferred/shaders/PhongLightingShadow.txt
diff --git a/fungi.mod/deferred/shaders/PostBasic.txt b/_OLD/fungi.mod/deferred/shaders/PostBasic.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/PostBasic.txt
rename to _OLD/fungi.mod/deferred/shaders/PostBasic.txt
diff --git a/fungi.mod/deferred/shaders/VecWColor.txt b/_OLD/fungi.mod/deferred/shaders/VecWColor.txt
similarity index 100%
rename from fungi.mod/deferred/shaders/VecWColor.txt
rename to _OLD/fungi.mod/deferred/shaders/VecWColor.txt
diff --git a/fungi.mod/particles/ParticleModules.js b/_OLD/fungi.mod/particles/ParticleModules.js
similarity index 100%
rename from fungi.mod/particles/ParticleModules.js
rename to _OLD/fungi.mod/particles/ParticleModules.js
diff --git a/fungi.mod/particles/ParticleSystem.js b/_OLD/fungi.mod/particles/ParticleSystem.js
similarity index 100%
rename from fungi.mod/particles/ParticleSystem.js
rename to _OLD/fungi.mod/particles/ParticleSystem.js
diff --git a/fungi.mod/particles/TransformFeedback.js b/_OLD/fungi.mod/particles/TransformFeedback.js
similarity index 100%
rename from fungi.mod/particles/TransformFeedback.js
rename to _OLD/fungi.mod/particles/TransformFeedback.js
diff --git a/fungi.mod/postEffects/shaders/PostBasic.txt b/_OLD/fungi.mod/postEffects/shaders/PostBasic.txt
similarity index 100%
rename from fungi.mod/postEffects/shaders/PostBasic.txt
rename to _OLD/fungi.mod/postEffects/shaders/PostBasic.txt
diff --git a/fungi.mod/postEffects/shaders/PostBasic2.txt b/_OLD/fungi.mod/postEffects/shaders/PostBasic2.txt
similarity index 100%
rename from fungi.mod/postEffects/shaders/PostBasic2.txt
rename to _OLD/fungi.mod/postEffects/shaders/PostBasic2.txt
diff --git a/fungi.mod/raycast/BoundingCapsule.js b/_OLD/fungi.mod/raycast/BoundingCapsule.js
similarity index 100%
rename from fungi.mod/raycast/BoundingCapsule.js
rename to _OLD/fungi.mod/raycast/BoundingCapsule.js
diff --git a/fungi.mod/raycast/BoundingSphere.js b/_OLD/fungi.mod/raycast/BoundingSphere.js
similarity index 100%
rename from fungi.mod/raycast/BoundingSphere.js
rename to _OLD/fungi.mod/raycast/BoundingSphere.js
diff --git a/fungi.mod/raycast/Ray.js b/_OLD/fungi.mod/raycast/Ray.js
similarity index 100%
rename from fungi.mod/raycast/Ray.js
rename to _OLD/fungi.mod/raycast/Ray.js
diff --git a/fungi.mod/shaders/Grid001.txt b/_OLD/fungi.mod/shaders/Grid001.txt
similarity index 100%
rename from fungi.mod/shaders/Grid001.txt
rename to _OLD/fungi.mod/shaders/Grid001.txt
diff --git a/fungi.mod/shaders/Grid002.txt b/_OLD/fungi.mod/shaders/Grid002.txt
similarity index 100%
rename from fungi.mod/shaders/Grid002.txt
rename to _OLD/fungi.mod/shaders/Grid002.txt
diff --git a/fungi.mod/shaders/Grid003.txt b/_OLD/fungi.mod/shaders/Grid003.txt
similarity index 100%
rename from fungi.mod/shaders/Grid003.txt
rename to _OLD/fungi.mod/shaders/Grid003.txt
diff --git a/fungi.mod/terrain/DynamicChunk.js b/_OLD/fungi.mod/terrain/DynamicChunk.js
similarity index 100%
rename from fungi.mod/terrain/DynamicChunk.js
rename to _OLD/fungi.mod/terrain/DynamicChunk.js
diff --git a/fungi.mod/terrain/PatchNine.js b/_OLD/fungi.mod/terrain/PatchNine.js
similarity index 100%
rename from fungi.mod/terrain/PatchNine.js
rename to _OLD/fungi.mod/terrain/PatchNine.js
diff --git a/fungi.mod/terrain/Terrain_Grid.js b/_OLD/fungi.mod/terrain/Terrain_Grid.js
similarity index 100%
rename from fungi.mod/terrain/Terrain_Grid.js
rename to _OLD/fungi.mod/terrain/Terrain_Grid.js
diff --git a/fungi.mod/terrain/Terrain_IsoGrid.js b/_OLD/fungi.mod/terrain/Terrain_IsoGrid.js
similarity index 100%
rename from fungi.mod/terrain/Terrain_IsoGrid.js
rename to _OLD/fungi.mod/terrain/Terrain_IsoGrid.js
diff --git a/fungi.mod/terrain/Terrain_old.js b/_OLD/fungi.mod/terrain/Terrain_old.js
similarity index 100%
rename from fungi.mod/terrain/Terrain_old.js
rename to _OLD/fungi.mod/terrain/Terrain_old.js
diff --git a/fungi.mod/voxel/DynamicVoxelSystem.js b/_OLD/fungi.mod/voxel/DynamicVoxelSystem.js
similarity index 100%
rename from fungi.mod/voxel/DynamicVoxelSystem.js
rename to _OLD/fungi.mod/voxel/DynamicVoxelSystem.js
diff --git a/fungi.mod/voxel/Voxel.js b/_OLD/fungi.mod/voxel/Voxel.js
similarity index 100%
rename from fungi.mod/voxel/Voxel.js
rename to _OLD/fungi.mod/voxel/Voxel.js
diff --git a/fungi.mod/voxel/VoxelChunk.js b/_OLD/fungi.mod/voxel/VoxelChunk.js
similarity index 100%
rename from fungi.mod/voxel/VoxelChunk.js
rename to _OLD/fungi.mod/voxel/VoxelChunk.js
diff --git a/fungi.mod/voxel/VoxelDynamicVao.js b/_OLD/fungi.mod/voxel/VoxelDynamicVao.js
similarity index 100%
rename from fungi.mod/voxel/VoxelDynamicVao.js
rename to _OLD/fungi.mod/voxel/VoxelDynamicVao.js
diff --git a/fungi.mod/voxel/VoxelRaycast.js b/_OLD/fungi.mod/voxel/VoxelRaycast.js
similarity index 100%
rename from fungi.mod/voxel/VoxelRaycast.js
rename to _OLD/fungi.mod/voxel/VoxelRaycast.js
diff --git a/fungi/gl.js b/_OLD/gl.js
similarity index 100%
rename from fungi/gl.js
rename to _OLD/gl.js
diff --git a/fungi/input/InputTracker.js b/_OLD/input/InputTracker.js
similarity index 100%
rename from fungi/input/InputTracker.js
rename to _OLD/input/InputTracker.js
diff --git a/fungi/net/Downloader.js b/_OLD/net/Downloader.js
similarity index 100%
rename from fungi/net/Downloader.js
rename to _OLD/net/Downloader.js
diff --git a/fungi/systems/BehaviourSystem.js b/_OLD/systems/BehaviourSystem.js
similarity index 100%
rename from fungi/systems/BehaviourSystem.js
rename to _OLD/systems/BehaviourSystem.js
diff --git a/fungi/systems/CameraSystem.js b/_OLD/systems/CameraSystem.js
similarity index 100%
rename from fungi/systems/CameraSystem.js
rename to _OLD/systems/CameraSystem.js
diff --git a/fungi/systems/DynamicVaoSystem.js b/_OLD/systems/DynamicVaoSystem.js
similarity index 100%
rename from fungi/systems/DynamicVaoSystem.js
rename to _OLD/systems/DynamicVaoSystem.js
diff --git a/fungi/systems/MovementSystem.js b/_OLD/systems/MovementSystem.js
similarity index 100%
rename from fungi/systems/MovementSystem.js
rename to _OLD/systems/MovementSystem.js
diff --git a/fungi/systems/RenderSystem.js b/_OLD/systems/RenderSystem.js
similarity index 100%
rename from fungi/systems/RenderSystem.js
rename to _OLD/systems/RenderSystem.js
diff --git a/fungi/systems/RightMouseSystem.js b/_OLD/systems/RightMouseSystem.js
similarity index 100%
rename from fungi/systems/RightMouseSystem.js
rename to _OLD/systems/RightMouseSystem.js
diff --git a/fungi/systems/TransformHierarchySystem.js b/_OLD/systems/TransformHierarchySystem.js
similarity index 100%
rename from fungi/systems/TransformHierarchySystem.js
rename to _OLD/systems/TransformHierarchySystem.js
diff --git a/fungi/systems/TransformNodeSystem.js b/_OLD/systems/TransformNodeSystem.js
similarity index 100%
rename from fungi/systems/TransformNodeSystem.js
rename to _OLD/systems/TransformNodeSystem.js
diff --git a/fungi/systems/TransformSystem.js b/_OLD/systems/TransformSystem.js
similarity index 100%
rename from fungi/systems/TransformSystem.js
rename to _OLD/systems/TransformSystem.js
diff --git a/ecs.txt b/ecs.txt
deleted file mode 100644
index 2d6cf70..0000000
--- a/ecs.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-Transform
-.Position
-.Rotation
-.Scale
-.LocalMatrix
-.WorldMatrix
-.Parent
-
-Renderable - Dependance ( Transform )
-.vao
-.drawMode
-.material
-.options
diff --git a/fungi/engine/App.js b/fungi/engine/App.js
index 0e38648..c4a8542 100644
--- a/fungi/engine/App.js
+++ b/fungi/engine/App.js
@@ -15,7 +15,8 @@ import InputSystem				from "./ecs/InputSystem.js";
 
 /*
 System Notes
-001 - Input
+001 - Input 
+100 - Misc : DynamicVerts
 700 - Physics
 800 - Transform
 801 - Camera
diff --git a/fungi/engine/Debug.js b/fungi/engine/Debug.js
index b091733..188c5d3 100644
--- a/fungi/engine/Debug.js
+++ b/fungi/engine/Debug.js
@@ -10,7 +10,7 @@ let eLine, ePoint;
 
 //#########################################################################
 class Debug{
-	static init( ecs, priority=1 ){
+	static init( ecs, priority=100 ){
 		ePoint	= DVerts.build( App.newDraw( "Debug_Point" ), "Debug_Points", "VecWColor", 0 );
 		eLine	= DVerts.build( App.newDraw( "Debug_Line" ), "Debug_Lines", "VecWColor", 1 );
 		DynamicVertsSystem.init( ecs, priority );
diff --git a/fungi/engine/_test_page.html b/fungi/engine/_test_page.html
index 23058c8..9f06720 100644
--- a/fungi/engine/_test_page.html
+++ b/fungi/engine/_test_page.html
@@ -1,7 +1,7 @@
 <!DOCTYPE html><html><head><title>Fungi</title></head><script type="module">
 
 import App			from "./App.js";
-//import FacedCube	from "../primitives/FacedCube.js";
+import FacedCube	from "../primitives/FacedCube.js";
 //import DVerts, { DynamicVertsSystem } from "./ecs/DynamicVerts.js";
 //import Debug from "./Debug.js";
 
@@ -10,7 +10,7 @@
 App.launch( onDraw, [
 	{ type:"shader", file:"/fungi/shaders/VecWColor.txt" },
 ])	//.then( ()=>App.loadModules( "./Debug.js" ) )
-	.then( ()=>App.loadScene( true ) )
+	.then( ()=>App.loadScene( false ) )
 	.then( ()=>init() )
 	.catch( (err)=>console.error( err ) );
 
@@ -23,10 +23,15 @@
 		.setRotAxis( [1,0,0], -15 * Math.PI / 180 );
 
 
-	App.debug.rawPoint(0, 0.5, 0, 2);
-	App.debug.line( [0,0,0], [0,0.5,0], 0 );
+	//App.debug.rawPoint(0, 0.5, 0, 2);
+	//App.debug.line( [0,0,0], [0,0.5,0], 0 );
+
+	cube = FacedCube("Cube");
+	cube2 = FacedCube("Cube2");
+	cube2.Node.setPos(0,1,0).setScl( 0.5 );
+
+	App.node.addChild( cube, cube2 );
 
-	//cube = FacedCube("Cube");
 	//let gfloor = GridFloor();
 	
 	//let e = DVerts.build( App.newDraw( "DVE" ), "Points", "VecWColor", 1 );
@@ -46,10 +51,11 @@
 	App.loopState( true );
 }
 
-let cube;
+let cube, cube2;
 function onDraw( dt, ss ){
 
-	//cube.Node.setRotAxis( [0,1,0], Math.sin( ss ) * Math.PI );
+	cube.Node.setRotAxis( [0,1,0], Math.sin( ss ) * Math.PI );
+	cube2.Node.setRotAxis( [0,1,0], Math.sin( ss ) * Math.PI );
 
 	App.ecs.updateSystems();
 }
diff --git a/fungi/engine/ecs/DynamicVerts.js b/fungi/engine/ecs/DynamicVerts.js
index dc8c2df..8536607 100644
--- a/fungi/engine/ecs/DynamicVerts.js
+++ b/fungi/engine/ecs/DynamicVerts.js
@@ -112,7 +112,7 @@ class DynamicVerts{
 const QUERY_COM = ["DynamicVerts"];
 
 class DynamicVertsSystem extends System{
-	static init( ecs, priority = 1 ){ ecs.addSystem( new DynamicVertsSystem(), priority ); }
+	static init( ecs, priority = 100 ){ ecs.addSystem( new DynamicVertsSystem(), priority ); }
 
 	constructor(){ super(); }
 	update( ecs ){
diff --git a/fungi/engine/ecs/Node.js b/fungi/engine/ecs/Node.js
index 8484e46..744421d 100644
--- a/fungi/engine/ecs/Node.js
+++ b/fungi/engine/ecs/Node.js
@@ -1,3 +1,9 @@
+/**
+ * @module fungi/engine/ecs/Node
+ * @version 1.0.0
+ * @author Pedro S. <sketchpunk@gmail.com>
+ */
+
 import { Components, System }	from "../Ecs.js";
 import Transform	from "../../maths/Transform.js";
 import Mat4			from "../../maths/Mat4.js";
@@ -5,33 +11,89 @@ import Quat 		from "../../maths/Quat.js";
 import Vec3 		from "../../maths/Vec3.js";
 
 //#########################################################################
+
+/** ECS Component to handle Transform Heirarchy of Entities */
 class Node{
+	/**
+	* Create a Node Component
+	*/
 	constructor(){
 		//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-		// Position / Rotation / Scale		
-		this.isModified		= true;
-		this.local			= new Transform();	
-		this.world			= new Transform();
-		this.modelMatrix	= new Mat4();
+		// Position / Rotation / Scale
+
+		/**
+		 * A flag to tell systems that data has been modified and requires updating
+		 * @public @type {boolean}
+		 */
+		this.isModified = true;
+
+		/**
+		 * Local space transform data
+		 * @public @type {Transform}
+		 */
+		this.local = new Transform();
+
+		/**
+		 * World space transform data, calculated by NodeSystem Update based on Transform Hierachy
+		 * @private @type {Transform}
+		 */
+		this.world = new Transform();
+
+		/**
+		 * Model matrix used in shaders. Calculated by NodeSystem based on world space transform data
+		 * @private @type {Mat4}
+		 */
+		this.modelMatrix = new Mat4();
+
 
 		//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 		// Heirachy
-		this.level			= 0;			// What level in the Hierachy
-		this.parent			= null;			// Entity reference of the parent
-		this.children		= [];			// List of Children Entities
+
+		/**
+		 * Cache at what level of the hierachy the node exists. Used for Sorting in NodeSystem.
+		 * @private @type {number}
+		 */
+		this.level = 0;
+
+		/**
+		 * Reference to the Entity Parent. May be null if there is no parent.
+		 * @private @type {?Entity}
+		 */
+		this.parent = null;
+
+		/**
+		 * List to references of Entity Children
+		 * @private @type {Entity[]}
+		 */
+		this.children = [];
 	}
 
+
 	////////////////////////////////////////////////////////////////////
 	// SETTERS
 	////////////////////////////////////////////////////////////////////
+		/**
+		 * Set local space position and sets modified to true
+		 * @param {(number|Vec3)} x - X local position or Vec3 to set x,y,z
+		 * @param {?number} y - Y Local position
+		 * @param {?number} z - Z Local position
+		 * @public @return {Node}
+		 */
 		setPos( x, y, z ){
 			if( arguments.length == 1 ) this.local.pos.copy( x );
-			else						this.local.pos.set( x, y, z);
+			else						this.local.pos.set( x, y, z );
 			
 			this.isModified = true;
 			return this;
 		}
 
+		/**
+		 * Add values to the local position and sets modified to true
+		 * @param {(number|Vec3)} x - X local position or Vec3 to set x,y,z
+		 * @param {?number} y - Y Local position
+		 * @param {?number} z - Z Local position
+		 * @public @return {Node}
+		 */
 		addPos( x, y, z ){
 			if( arguments.length == 1 ) this.local.pos.add( x );
 			else{
@@ -43,16 +105,43 @@ class Node{
 			return this;
 		}
 
+		/**
+		 * Set rotation based on an Axis and angle in radians
+		 * @param {Vec3} axis - Unit vector of an axis of rotation
+		 * @param {number} ang - Angle in radians
+		 * @public @return {Node}
+		 */
 		setRotAxis( axis, ang ){
 			this.local.rot.setAxisAngle( axis, ang );
 			this.isModified = true;
 			return this;
 		}
 
+		/**
+		 * Sets local scale and sets modified to true
+		 * @param {number} x - X local scale, if the only value passed in then it will scale all axises by X
+		 * @param {?number} y - Y Local scale
+		 * @param {?number} z - Z Local scale
+		 * @public @return {Node}
+		 */
+		setScl( x, y, z ){
+			if( arguments.length == 1 ) this.local.scl.set( x, x, x );
+			else						this.local.scl.set( x, y, z );
+			
+			this.isModified = true;
+			return this;
+		}
+
 
 	////////////////////////////////////////////////////////////////////
 	// Child Management
 	////////////////////////////////////////////////////////////////////
+		/**
+		 * Create a Parent-Child relationship between two Entities
+		 * @param {Entity} pe - Parent Entity
+		 * @param {Entity} ce - Child Entity
+		 * @public @return {Node}
+		 */
 		static addChild( pe, ce ){
 			let pn = pe.Node;
 
@@ -75,9 +164,15 @@ class Node{
 			//if child has its own children, update their level values
 			if(cn.children.length > 0) updateChildLevel( cn );
 
-			return TransformNode;
+			return Node;
 		}
 
+		/**
+		 * Remove the Parent-Child relationship between two entities.
+		 * @param {Entity} pe - Parent Entity
+		 * @param {Entity} ce - Child Entity
+		 * @public @return {Node}
+		 */
 		static removeChild( pe, ce ){
 			var idx = pe.Node.children.indexOf( ce );
 
@@ -97,6 +192,13 @@ class Node{
 	////////////////////////////////////////////////////////////////////
 	// WORLD SPACE
 	////////////////////////////////////////////////////////////////////
+		/**
+		 * Get direction of an Entity based on its World Rotation
+		 * @param {Entity} e - Entity that you want to get direction for.
+		 * @param {number} [dir=0] - Which direction you want, Forward:0, Left:1, Up:2
+		 * @param {?Vec3} [out=null] - Pass in a Vec3, else one will be created.
+		 * @public @return {Vec3}
+		 */
 		static getDir( e, dir=0, out=null ){
 			let q = Node.getWorldRot( e );
 			out = out || new Vec3();
@@ -109,6 +211,12 @@ class Node{
 			return out;
 		}
 
+		/**
+		 * Get the world rotation of an entity
+		 * @param {Entity} e - Entity you want get the rotation of.
+		 * @param {?Quat} [out=null] - Passin a Quaternion Reference, else a new one will be created.
+		 * @public @return {Quat}
+		 */
 		static getWorldRot( e, out = null ){
 			out = out || new Quat();
 
@@ -155,13 +263,30 @@ class Node{
 //#########################################################################
 const QUERY_COM = [ "Node" ];
 
+
+/**
+* ECS System that handles updating Transform Hierachy data along with create ModelMatrix based on World Space Transform
+* @extends System
+*/
 class NodeSystem extends System{
+
+	/**
+	 * Setup the system automaticly to an ECS reference
+	 * @param {Ecs} ecs - Instance of an Ecs object
+	 * @param {number} [priority=] - What the priority the system has compared to others during update.
+	 * @param {number} [priority2=] - Priority for the second system that handles cleanup for Nodes.
+	 */
 	static init( ecs, priority = 800, priority2 = 1000 ){ 
 		ecs.addSystem( new NodeSystem(), priority );
 		ecs.addSystem( new NodeCleanupSystem(), priority2 );
 	}
 
 	constructor(){ super(); }
+
+	/**
+	* System Update
+	* @param {Ecs} ecs
+	*/
 	update( ecs ){
 		let e,		// Entity
 			cn,		// Child Node ( only if parent node exists )
@@ -190,8 +315,17 @@ class NodeSystem extends System{
 
 
 //#########################################################################
+/**
+* ECS System that handles updating Transform Hierachy data along with create ModelMatrix based on World Space Transform
+* @extends System
+*/
 class NodeCleanupSystem extends System{
 	constructor(){ super(); }
+
+	/**
+	* System Update
+	* @param {Ecs} ecs
+	*/
 	update(ecs){
 		let e, ary = ecs.queryEntities( QUERY_COM, thSort );
 		for( e of ary ) if( e.Node.isModified ) e.Node.isModified = true;
@@ -200,7 +334,15 @@ class NodeCleanupSystem extends System{
 
 
 //#########################################################################
-//Compare function to sort entities based on the level of the hierarchy.
+// HELPER
+
+/**
+ * Compare function to sort entities based on the level of the hierarchy.
+ * @param {Entity} a
+ * @param {Entity} b
+ * @return {number}
+ * @private
+ */
 function thSort( a, b ){
 	//Sort by Hierarachy Levels so parents are calculated before children
 	let lvlA = a.Node.level,
@@ -211,7 +353,11 @@ function thSort( a, b ){
 	else					return  1;	// A > B
 }
 
-
+/**
+ * Update the level of all the child nodes of node
+ * @param {node} n
+ * @private
+ */
 function updateChildLevel( n ){
 	let c, cn;
 	for(c of n.children){
diff --git a/fungi/engine/ecs/Transform.js b/fungi/engine/ecs/Transform.js
deleted file mode 100644
index e2a534f..0000000
--- a/fungi/engine/ecs/Transform.js
+++ /dev/null
@@ -1,36 +0,0 @@
-import Maths, { Vec3, Quat, Mat4 }	from "../Maths.js";
-import { Components }				from "../Ecs.js";
-
-class Transform{
-	constructor(){
-		this.isModified	= true;
-		this.position		= new Vec3();
-		this.scale			= new Vec3(1,1,1);
-		this.rotation		= new Quat();
-		this.modelMatrix	= new Mat4();
-	}
-
-	
-	//set position(v){	this._isModified = true; this._position.copy(v); }
-	//get position(){		return this._position.clone(); }
-	setPosition(x,y,z){	this.isModified = true; this.position.set(x,y,z); return this; }
-
-
-	//set scale(v){		this._isModified = true; this._scale.copy(v); }
-	//get scale(){		return this._scale.clone(); }
-	setScale(x,y,z){
-		this.isModified = true;
-		if(arguments.length == 1)	this.scale.set(x,x,x);
-		else 						this.scale.set(x,y,z);
-		return this;
-	}
-	
-	
-	//set rotation(v){	this._isModified = true; this._rotation.copy(v); }
-	//get rotation(){		return this._rotation.clone(); }
-	setDegrees(deg, axis="y"){ this.isModified = true; this.rotation["r"+axis](deg * Maths.DEG2RAD); return this; }
-	setAxisAngle(v, a){ this.isModified = true; this.rotation.setAxisAngle(v,a); return this; }
-
-} Components(Transform);
-
-export default Transform;
\ No newline at end of file
diff --git a/fungi/engine/ecs/TransformNode.js b/fungi/engine/ecs/TransformNode.js
deleted file mode 100644
index e922545..0000000
--- a/fungi/engine/ecs/TransformNode.js
+++ /dev/null
@@ -1,190 +0,0 @@
-import { Vec3, Quat }	from "../Maths.js";
-import { Components }	from "../Ecs.js";
-
-/** Class representing a point. 
- * @extends Point
- */
-class TransformNode{
-
-	/**
- 	* Represents a book.
- 	* @constructor  no need for classes
- 	* @param {string} title - The title of the book.
- 	* @param {string} author - The author of the book.
- 	* @return {number} The x value.
- 	*/
-	constructor(){
-		this.level			= 0;			// What level in the Hierachy
-		this.parent			= null;			// Entity reference of the parent
-		this.parentModified	= false;		// When a parent's Local/World Matrix updates, children are marked to update their world matrix
-		this.children		= [];			// List of Children Entities
-
-		this.scale			= new Vec3();	// Accumulated Transform Values, World Space
-		this.position		= new Vec3();
-		this.rotation		= new Quat();
-	}
-
-
-	////////////////////////////////////////////////////////////////////
-	// Child Management
-	////////////////////////////////////////////////////////////////////
-		static addChild(ep, ec){
-			let ph = ep.com.TransformNode;
-
-			if( ph.children.indexOf(ec) != -1){
-				console.log("%s is already a child of %s", ec.name, ep.name);
-				return Hierarchy;
-			}
-
-			//...............................................
-			//if child already has a parent, remove itself
-			let ch = ec.com.TransformNode;
-			if(ch.parent != null) TransformNode.removeChild( ch.parent, ec );
-
-			//...............................................
-			ch.parent	= ep;				//Set parent on the child
-			ch.level	= ph.level + 1;		//Set the level value for the child
-			ph.children.push( ec );			//Add child to parent's children list
-
-			//...............................................
-			//if child has its own children, update their level values
-			if(ch.children.length > 0) updateChildLevel( ch );
-
-			return TransformNode;
-		}
-
-		static removeChild(ep, ec){
-			var idx = ep.com.TransformNode.children.indexOf(ec);
-
-			if(idx == -1) console.log("%s is not a child of %s", ec.name, ep.name);
-			else{
-				//Update Child Data
-				ec.com.TransformNode.parent	= null;
-				ec.com.TransformNode.level		= 0;
-
-				//Remove from parent
-				ep.com.TransformNode.children.splice(idx,1);
-			}
-
-			return TransformNode;
-		}
-
-	////////////////////////////////////////////////////////////////////
-	//
-	////////////////////////////////////////////////////////////////////
-	static updateNode(e){
-		let cn = e.com.TransformNode,
-			ct = e.com.Transform;
-
-		if(cn.parent == null){
-			cn.position.copy( ct.position );
-			cn.rotation.copy( ct.rotation );
-			cn.scale.copy( ct.scale );
-		}else{
-			let pn = cn.parent.com.TransformNode;
-
-			pn.scale.mul( ct.scale, cn.scale );				// parent.scale * child.scale
-			pn.rotation.mul( ct.rotation, cn.rotation );	// parent.rotation * child.rotation
-
-			//Calc Position
-			// parent.position + ( parent.rotation * ( parent.scale * child.position ) )
-			Vec3.mul(pn.scale, ct.position, cn.position);	// p.scale * c.position;
-			Vec3.transformQuat(cn.position, pn.rotation, cn.position).add(pn.position);
-		}
-	}
-
-	static transform(lPosition, lRotation, lScale, wPosition, wRotation, wScale, pPosition=null, pRotation=null, pScale=null){
-		if(pPosition == null){
-			wPosition.copy(lPosition);
-			wRotation.copy(lRotation);
-			wScale.copy(lScale);
-		}else{
-			pScale.mul( lScale, wScale );
-			pRotation.mul( lRotation, wRotation );
-
-			// parent.position + ( parent.rotation * ( parent.scale * child.position ) )
-			Vec3.mul( pScale, lPosition, wPosition ); // p.scale * c.position;
-			Vec3.transformQuat(wPosition, pRotation, wPosition).add( pPosition );
-		}
-	}
-
-	static getWorldTransform(e, wPos, wRot, wScale){
-		var ary	= [e.com.Transform],
-			t	= e.com.TransformNode;
-
-		//Get the parent tree of the entity
-		while(t.parent != null){
-			ary.push( t.parent.com.Transform );
-			t = t.parent.com.TransformNode;
-		}
-
-		let last 	= ary.length - 1,
-			tPos	= new Vec3(),
-			tRot 	= new Quat(),
-			tScale 	= new Vec3();
-
-		wPos.copy( ary[last].position );
-		wRot.copy( ary[last].rotation );
-		wScale.copy( ary[last].scale );
-
-		for(let i= last-1; i >= 0; i--){
-			t = ary[i];
-			TransformNode.transform(t.position, t.rotation, t.scale, tPos, tRot, tScale, wPos, wRot, wScale);
-
-			wPos.copy( tPos );
-			wRot.copy( tRot );
-			wScale.copy( tScale);
-		}
-	}
-
-	static getWorldPosition(e, out){
-		var ary	= [e.com.Transform],
-			t	= e.com.TransformNode;
-
-		//.............................................
-		//Get the parent tree of the entity
-		while(t.parent != null){
-			ary.push( t.parent.com.Transform );
-			t = t.parent.com.TransformNode;
-		}
-
-		//.............................................
-		let last 	= ary.length - 1,
-			pos  	= new Vec3(),
-			pPos	= new Vec3( ary[last].position ),
-			pRot 	= new Quat( ary[last].rotation ),
-			pScale 	= new Vec3( ary[last].scale );
-
-		for(let i= last-1; i >= 0; i--){
-			t = ary[i];
-
-			// parent.position + ( parent.rotation * ( parent.scale * child.position ) )
-			Vec3.mul( pScale, t.position, pos ); // p.scale * c.position;
-			pPos.add( Vec3.transformQuat(pos, pRot, pos) );
-
-			if(i != 0){ //if last item, dont bother with the rest.
-				pScale.mul( t.scale );
-				pRot.mul( t.rotation );
-			}
-		}
-
-		//.............................................
-		out = out || new Vec3();
-		return out.copy( pPos );
-	}
-} Components(TransformNode);
-
-
-//#######################################################################
-//recursive function to update the heirarachy levels in children
-function updateChildLevel(h){
-	let c, th;
-	for(c of h.children){
-		th			= c.com.TransformNode;
-		th.level	= h.level + 1;
-		if(th.children.length > 0) updateChildLevel( th );
-	}
-}
-
-
-export default TransformNode;
\ No newline at end of file
diff --git a/fungi/maths/Axis.js b/fungi/maths/Axis.js
index 06004c0..d810d88 100644
--- a/fungi/maths/Axis.js
+++ b/fungi/maths/Axis.js
@@ -18,92 +18,106 @@ class Axis{
 		this.z = new Vec3( Vec3.FORWARD );
 	}
 
-	//Passing in Vectors.
-	set( x, y, z, doNormalize = false ){
-		this.x.copy( x );
-		this.y.copy( y );
-		this.z.copy( z );
-
-		if(doNormalize){
-			this.x.normalize();
-			this.y.normalize();
-			this.z.normalize();
+	////////////////////////////////////////////////////////////////////
+	// SETTERS
+	////////////////////////////////////////////////////////////////////
+		
+		//Passing in Vectors.
+		set( x, y, z, doNormalize = false ){
+			this.x.copy( x );
+			this.y.copy( y );
+			this.z.copy( z );
+
+			if(doNormalize){
+				this.x.normalize();
+				this.y.normalize();
+				this.z.normalize();
+			}
+
+			return true;
 		}
 
-		return true;
-	}
-
-	//Create an axis based on a looking direction
-	lookAt( v ){
-		//If the vector is pretty much forward, just do set default axis.
-		var test = Vec3.nearZero( v );
-		if(test.x == 0 && test.y == 0){
-			this.z.copy( Vec3.FORWARD );
-			this.y.copy( Vec3.UP );
-			this.x.copy( Vec3.LEFT );
+		//Create axis based on a Quaternion
+		setQuat( q ){
+			// Same code for Quat to Matrix 3 conversion
+			let x = q[0], y = q[1], z = q[2], w = q[3],
+				x2 = x + x,
+				y2 = y + y,
+				z2 = z + z,
+				xx = x * x2,
+				yx = y * x2,
+				yy = y * y2,
+				zx = z * x2,
+				zy = z * y2,
+				zz = z * z2,
+				wx = w * x2,
+				wy = w * y2,
+				wz = w * z2;
+
+			this.x.set( 1 - yy - zz,	yx + wz,		zx - wy );
+			this.y.set( yx - wz,		1 - xx - zz,	zy + wx );
+			this.z.set( zx + wy,		zy - wx,		1 - xx - yy );
 			return this;
 		}
 
-		Vec3.norm(v, this.z);	//Direction is the forward vector
-		let dot = Vec3.dot(Vec3.LEFT, this.z);
+		//Create an axis based on a looking direction
+		lookAt( v ){
+			//If the vector is pretty much forward, just do set default axis.
+			var test = Vec3.nearZero( v );
+			if(test.x == 0 && test.y == 0){
+				this.z.copy( Vec3.FORWARD );
+				this.y.copy( Vec3.UP );
+				this.x.copy( Vec3.LEFT );
+				return this;
+			}
+
+			Vec3.norm(v, this.z);	//Direction is the forward vector
+			let dot = Vec3.dot(Vec3.LEFT, this.z);
+
+			// If dot product is in the negative, need to use BACK (0,0,-1) 
+			// to get the correct up direction, else up will point down.
+			if(dot >= 0)	Vec3.cross(Vec3.FORWARD, this.z, this.y).normalize();
+			else			Vec3.cross(Vec3.BACK, this.z, this.y).normalize();
+
+			Vec3.cross(this.z, this.y, this.x).normalize();
+			return this;
+		}
 
-		// If dot product is in the negative, need to use BACK (0,0,-1) 
-		// to get the correct up direction, else up will point down.
-		if(dot >= 0)	Vec3.cross(Vec3.FORWARD, this.z, this.y).normalize();
-		else			Vec3.cross(Vec3.BACK, this.z, this.y).normalize();
+	////////////////////////////////////////////////////////////////////
+	//  
+	////////////////////////////////////////////////////////////////////
 
-		Vec3.cross(this.z, this.y, this.x).normalize();
-		return this;
-	}
+		//Axis is pretty much a Rotation Matrix, so easy to apply rotation to a vector.
+		transformVec3(v, out){
+			var x = v[0], y = v[1], z = v[2];
+			
+			out = out || new Vec3();
 
-	//Create axis based on a Quaternion
-	setQuat( q ){
-		// Same code for Quat to Matrix 3 conversion
-		let x = q[0], y = q[1], z = q[2], w = q[3],
-			x2 = x + x,
-			y2 = y + y,
-			z2 = z + z,
-			xx = x * x2,
-			yx = y * x2,
-			yy = y * y2,
-			zx = z * x2,
-			zy = z * y2,
-			zz = z * z2,
-			wx = w * x2,
-			wy = w * y2,
-			wz = w * z2;
-
-		this.x.set( 1 - yy - zz,	yx + wz,		zx - wy );
-		this.y.set( yx - wz,		1 - xx - zz,	zy + wx );
-		this.z.set( zx + wy,		zy - wx,		1 - xx - yy );
-		return this;
-	}
-
-	//Axis is pretty much a Rotation Matrix, so easy to apply rotation to a vector.
-	transformVec3(v, out){
-		var x = v[0], y = v[1], z = v[2];
-		
-		out = out || new Vec3();
+			out[0] = x * this.x[0] + y * this.y[0] + z * this.z[0];
+			out[1] = x * this.x[1] + y * this.y[1] + z * this.z[1];
+			out[2] = x * this.x[2] + y * this.y[2] + z * this.z[2];
+			return out;
+		}
 
-		out[0] = x * this.x[0] + y * this.y[0] + z * this.z[0];
-		out[1] = x * this.x[1] + y * this.y[1] + z * this.z[1];
-		out[2] = x * this.x[2] + y * this.y[2] + z * this.z[2];
-		return out;
-	}
 
-	static debug(DVao, e, axis, origin=null, scl=1.0){
-		origin = origin || Vec3.ZERO;
+	////////////////////////////////////////////////////////////////////
+	// STATIC
+	////////////////////////////////////////////////////////////////////
+		/*
+		static debug(DVao, e, axis, origin=null, scl=1.0){
+			origin = origin || Vec3.ZERO;
 
-		var v = new Vec3();
-		v.copy(axis.z).scale( scl ).add(origin);
-		DVao.vecLine(e, origin, v, 0);
+			var v = new Vec3();
+			v.copy(axis.z).scale( scl ).add(origin);
+			DVao.vecLine(e, origin, v, 0);
 
-		v.copy(axis.y).scale( scl ).add(origin);
-		DVao.vecLine(e, origin, v, 2);
+			v.copy(axis.y).scale( scl ).add(origin);
+			DVao.vecLine(e, origin, v, 2);
 
-		v.copy(axis.x).scale( scl ).add(origin);
-		DVao.vecLine(e, origin, v, 6);
-	}
+			v.copy(axis.x).scale( scl ).add(origin);
+			DVao.vecLine(e, origin, v, 6);
+		}
+		*/
 }
 
 export default Axis;
\ No newline at end of file
diff --git a/fungi/maths/DualQuat.js b/fungi/maths/DualQuat.js
index c4f8f0d..b3187bd 100644
--- a/fungi/maths/DualQuat.js
+++ b/fungi/maths/DualQuat.js
@@ -11,336 +11,360 @@ class DualQuat extends Float32Array{
 		this.set(q,t);
 	}
 
-	copy(a){
-		this[0] = a[0];
-		this[1] = a[1];
-		this[2] = a[2];
-		this[3] = a[3];
-		this[4] = a[4];
-		this[5] = a[5];
-		this[6] = a[6];
-		this[7] = a[7];
-		return this;
-	}
-
-	//Adds two dual quat's
-	add(q,out){
-		out = out || this;
-		out[0] = this[0] + q[0];
-		out[1] = this[1] + q[1];
-		out[2] = this[2] + q[2];
-		out[3] = this[3] + q[3];
-		out[4] = this[4] + q[4];
-		out[5] = this[5] + q[5];
-		out[6] = this[6] + q[6];
-		out[7] = this[7] + q[7];
-		return this;
-	}
-
-	//Multiplies two dual quat's
-	mul(q,out){
-		out = out || this;
-
-		var ax0 = this[0], ay0 = this[1], az0 = this[2], aw0 = this[3],
-			ax1 = this[4], ay1 = this[5], az1 = this[6], aw1 = this[7],
-			bx0 = q[0], by0 = q[1], bz0 = q[2], bw0 = q[3],
-			bx1 = q[4], by1 = q[5], bz1 = q[6], bw1 = q[7];
-
-		out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;
-		out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;
-		out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;
-		out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;
-		out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;
-		out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;
-		out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;
-		out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;
-		return this;
-	}
+	////////////////////////////////////////////////////////////////////
+	// SETTERS
+	////////////////////////////////////////////////////////////////////
+		copy(a){
+			this[0] = a[0];
+			this[1] = a[1];
+			this[2] = a[2];
+			this[3] = a[3];
+			this[4] = a[4];
+			this[5] = a[5];
+			this[6] = a[6];
+			this[7] = a[7];
+			return this;
+		}
 
-	scale(s,out){
-		out = out || this;
-		out[0] = this[0] * s;
-		out[1] = this[1] * s;
-		out[2] = this[2] * s;
-		out[3] = this[3] * s;
-		out[4] = this[4] * s;
-		out[5] = this[5] * s;
-		out[6] = this[6] * s;
-		out[7] = this[7] * s;
-		return this;
-	}
+		set(q,v){
+			var nq = null;
+			if(q != undefined && q != null){
+				nq = [0,0,0,1];
+				q.normalize(nq);
+			}
+
+			v = v || null;
+
+			if(nq != null & v != null)			DualQuat.fromRotationTranslation(this,nq,v);
+			else if(nq != null && v == null)	DualQuat.fromRotation(this,nq);
+			else if(nq == null && v != null)	DualQuat.fromTranslation(this,v);
+			else{								//identity
+				this[0] = 0;
+				this[1] = 0;
+				this[2] = 0;
+				this[3] = 1;
+				this[4] = 0;
+				this[5] = 0;
+				this[6] = 0;
+				this[7] = 0;
+			}
+
+			return this;
+		}
 
-	//Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper
-	invert(out){
-		out = out || this;
-		var sqlen = this.squaredLength(); //Todo, do 1/sqlen then mul the value
-
-		out[0] = -this[0] / sqlen;
-		out[1] = -this[1] / sqlen;
-		out[2] = -this[2] / sqlen;
-		out[3] =  this[3] / sqlen;
-		out[4] = -this[4] / sqlen;
-		out[5] = -this[5] / sqlen;
-		out[6] = -this[6] / sqlen;
-		out[7] =  this[7] / sqlen;
-		return this;
-	}
+		squaredLength(){ return this[0]*this[0] + this[1]*this[1] + this[2]*this[2] + this[3]*this[3]; }
+
+
+	////////////////////////////////////////////////////////////////////
+	// SELF OPERATIONS
+	////////////////////////////////////////////////////////////////////
+		//Adds two dual quat's
+		add(q,out){
+			out = out || this;
+			out[0] = this[0] + q[0];
+			out[1] = this[1] + q[1];
+			out[2] = this[2] + q[2];
+			out[3] = this[3] + q[3];
+			out[4] = this[4] + q[4];
+			out[5] = this[5] + q[5];
+			out[6] = this[6] + q[6];
+			out[7] = this[7] + q[7];
+			return this;
+		}
 
-	squaredLength(){ return this[0]*this[0] + this[1]*this[1] + this[2]*this[2] + this[3]*this[3]; }
+		//Multiplies two dual quat's
+		mul(q,out){
+			out = out || this;
+
+			var ax0 = this[0], ay0 = this[1], az0 = this[2], aw0 = this[3],
+				ax1 = this[4], ay1 = this[5], az1 = this[6], aw1 = this[7],
+				bx0 = q[0], by0 = q[1], bz0 = q[2], bw0 = q[3],
+				bx1 = q[4], by1 = q[5], bz1 = q[6], bw1 = q[7];
+
+			out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;
+			out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;
+			out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;
+			out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;
+			out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;
+			out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;
+			out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;
+			out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;
+			return this;
+		}
 
-	set(q,v){
-		var nq = null;
-		if(q != undefined && q != null){
-			nq = [0,0,0,1];
-			q.normalize(nq);
+		scale(s,out){
+			out = out || this;
+			out[0] = this[0] * s;
+			out[1] = this[1] * s;
+			out[2] = this[2] * s;
+			out[3] = this[3] * s;
+			out[4] = this[4] * s;
+			out[5] = this[5] * s;
+			out[6] = this[6] * s;
+			out[7] = this[7] * s;
+			return this;
 		}
 
-		v = v || null;
-
-		if(nq != null & v != null)			DualQuat.fromRotationTranslation(this,nq,v);
-		else if(nq != null && v == null)	DualQuat.fromRotation(this,nq);
-		else if(nq == null && v != null)	DualQuat.fromTranslation(this,v);
-		else{								//identity
-			this[0] = 0;
-			this[1] = 0;
-			this[2] = 0;
-			this[3] = 1;
-			this[4] = 0;
-			this[5] = 0;
-			this[6] = 0;
-			this[7] = 0;
+		//Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper
+		invert(out){
+			out = out || this;
+			var sqlen = this.squaredLength(); //Todo, do 1/sqlen then mul the value
+
+			out[0] = -this[0] / sqlen;
+			out[1] = -this[1] / sqlen;
+			out[2] = -this[2] / sqlen;
+			out[3] =  this[3] / sqlen;
+			out[4] = -this[4] / sqlen;
+			out[5] = -this[5] / sqlen;
+			out[6] = -this[6] / sqlen;
+			out[7] =  this[7] / sqlen;
+			return this;
 		}
 
-		return this;
-	}
 
-	//Creates a dual quat from a quaternion and a translation
-	static fromRotationTranslation(out,q,t){
-		var ax = t[0] * 0.5, ay = t[1] * 0.5, az = t[2] * 0.5,
-			bx = q[0], by = q[1], bz = q[2], bw = q[3];
-
-		out[0] = bx;
-		out[1] = by;
-		out[2] = bz;
-		out[3] = bw;
-		out[4] =  ax * bw + ay * bz - az * by;
-		out[5] =  ay * bw + az * bx - ax * bz;
-		out[6] =  az * bw + ax * by - ay * bx;
-		out[7] = -ax * bx - ay * by - az * bz;
-		return out;
-	}
+	////////////////////////////////////////////////////////////////////
+	// STATIC SETTERS
+	////////////////////////////////////////////////////////////////////
+
+		//Creates a dual quat from a quaternion and a translation
+		static fromRotationTranslation(out,q,t){
+			var ax = t[0] * 0.5, ay = t[1] * 0.5, az = t[2] * 0.5,
+				bx = q[0], by = q[1], bz = q[2], bw = q[3];
+
+			out[0] = bx;
+			out[1] = by;
+			out[2] = bz;
+			out[3] = bw;
+			out[4] =  ax * bw + ay * bz - az * by;
+			out[5] =  ay * bw + az * bx - ax * bz;
+			out[6] =  az * bw + ax * by - ay * bx;
+			out[7] = -ax * bx - ay * by - az * bz;
+			return out;
+		}
 
-	static fromTranslation(out,t){
-		out[0] = 0;
-		out[1] = 0;
-		out[2] = 0;
-		out[3] = 1;
-		out[4] = t[0] * 0.5;
-		out[5] = t[1] * 0.5;
-		out[6] = t[2] * 0.5;
-		out[7] = 0;
-		return out;
-	}
+		static fromTranslation(out,t){
+			out[0] = 0;
+			out[1] = 0;
+			out[2] = 0;
+			out[3] = 1;
+			out[4] = t[0] * 0.5;
+			out[5] = t[1] * 0.5;
+			out[6] = t[2] * 0.5;
+			out[7] = 0;
+			return out;
+		}
 
-	static fromRotation(out,q){
-		out[0] = q[0];
-		out[1] = q[1];
-		out[2] = q[2];
-		out[3] = q[3];
-		out[4] = 0;
-		out[5] = 0;
-		out[6] = 0;
-		out[7] = 0;
-		return out;
-	}
+		static fromRotation(out,q){
+			out[0] = q[0];
+			out[1] = q[1];
+			out[2] = q[2];
+			out[3] = q[3];
+			out[4] = 0;
+			out[5] = 0;
+			out[6] = 0;
+			out[7] = 0;
+			return out;
+		}
 
-	static getTranslation(a, out){
-		var ax =  a[4], ay =  a[5], az =  a[6], aw = a[7],
-			bx = -a[0], by = -a[1], bz = -a[2], bw = a[3];
+		static getTranslation(a, out){
+			var ax =  a[4], ay =  a[5], az =  a[6], aw = a[7],
+				bx = -a[0], by = -a[1], bz = -a[2], bw = a[3];
 
-		out = out || new Array(3);
-		out[0] = (ax * bw + aw * bx + ay * bz - az * by)*2;
-		out[1] = (ay * bw + aw * by + az * bx - ax * bz)*2;
-		out[2] = (az * bw + aw * bz + ax * by - ay * bx)*2;
-		return out;
-	}
+			out = out || new Array(3);
+			out[0] = (ax * bw + aw * bx + ay * bz - az * by)*2;
+			out[1] = (ay * bw + aw * by + az * bx - ax * bz)*2;
+			out[2] = (az * bw + aw * bz + ax * by - ay * bx)*2;
+			return out;
+		}
 
-	//Multiplies two dual quat's
-	static mul(a, b, out){
-		out = out || new DualQuat();
-
-		var ax0 = a[0], ay0 = a[1], az0 = a[2], aw0 = a[3],
-			ax1 = a[4], ay1 = a[5], az1 = a[6], aw1 = a[7],
-			bx0 = b[0], by0 = b[1], bz0 = b[2], bw0 = b[3],
-			bx1 = b[4], by1 = b[5], bz1 = b[6], bw1 = b[7];
-		out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;
-		out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;
-		out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;
-		out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;
-		out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;
-		out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;
-		out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;
-		out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;
-		return out;
-	}
 
-	//Translates a dual quat by the given vector
-	static translate(out,a,v){
-		var ax1 = a[0], ay1 = a[1], az1 = a[2], aw1 = a[3],
-			ax2 = a[4], ay2 = a[5], az2 = a[6], aw2 = a[7],
-			bx1 = v[0] * 0.5, by1 = v[1] * 0.5, bz1 = v[2] * 0.5;
-
-		out[0] = ax1;
-		out[1] = ay1;
-		out[2] = az1;
-		out[3] = aw1;
-		out[4] =  aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2;
-		out[5] =  aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2;
-		out[6] =  aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2;
-		out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2;
-		return out;
-	}
+	////////////////////////////////////////////////////////////////////
+	// STATIC OPERATIONS
+	////////////////////////////////////////////////////////////////////
+
+		// Multiplies two dual quat's
+		static mul(a, b, out){
+			out = out || new DualQuat();
+
+			var ax0 = a[0], ay0 = a[1], az0 = a[2], aw0 = a[3],
+				ax1 = a[4], ay1 = a[5], az1 = a[6], aw1 = a[7],
+				bx0 = b[0], by0 = b[1], bz0 = b[2], bw0 = b[3],
+				bx1 = b[4], by1 = b[5], bz1 = b[6], bw1 = b[7];
+			out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;
+			out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;
+			out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;
+			out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;
+			out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;
+			out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;
+			out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;
+			out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;
+			return out;
+		}
 
-	//Rotates a dual quat around the X axis
-	static rotateX(out,a,rad){
-		var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
-			ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
-		//Trans
-		var ax1 = ax * bw + aw * bx + ay * bz - az * by,
-		ay1 = ay * bw + aw * by + az * bx - ax * bz,
-		az1 = az * bw + aw * bz + ax * by - ay * bx,
-		aw1 = aw * bw - ax * bx - ay * by - az * bz;
-
-		//Rotate it 
-		quat.rotateX(out, a, rad);
-
-		bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
-		out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
-		out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
-		out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
-		out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
-		return out;
-	}
+		static transformVec3(dq, va, out = null){
+			let pos	= DualQuat.getTranslation( dq );
+			out		= out || new Vec3();
 
-	static rotateY(out,a,rad){
-		var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
-			ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
-		
-		//Trans
-		var ax1 = ax * bw + aw * bx + ay * bz - az * by,
-		ay1 = ay * bw + aw * by + az * bx - ax * bz,
-		az1 = az * bw + aw * bz + ax * by - ay * bx,
-		aw1 = aw * bw - ax * bx - ay * by - az * bz;
-
-		//Rotate it 
-		quat.rotateY(out, a, rad);
-
-		bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
-		out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
-		out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
-		out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
-		out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
-		return out;
-	}
+			Vec3.transformQuat(va, dq, out);
+			out[0] += pos[0];
+			out[1] += pos[1];
+			out[2] += pos[2];
 
-	static rotateZ(out,a,rad){
-		//Get the translation
-		var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
-		ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
-
-		//Trans
-		var ax1 = ax * bw + aw * bx + ay * bz - az * by,
-		ay1 = ay * bw + aw * by + az * bx - ax * bz,
-		az1 = az * bw + aw * bz + ax * by - ay * bx,
-		aw1 = aw * bw - ax * bx - ay * by - az * bz;
-
-		//Rotate it 
-		quat.rotateZ(out, a, rad);
-
-		bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
-		out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
-		out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
-		out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
-		out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
-		return out;
-	}
+			return out;
+		}
 
-	//Rotates a dual quat by a given quaternion (a * q)
-	static rotateByQuatAppend(out,a,q){
-		var qx = q[0], qy = q[1], qz = q[2], qw = q[3],
-			ax = a[0], ay = a[1], az = a[2], aw = a[3];
-
-		out[0] = ax * qw + aw * qx + ay * qz - az * qy;
-		out[1] = ay * qw + aw * qy + az * qx - ax * qz;
-		out[2] = az * qw + aw * qz + ax * qy - ay * qx;
-		out[3] = aw * qw - ax * qx - ay * qy - az * qz;
-		
-		ax = a[4]; ay = a[5]; az = a[6]; aw = a[7];
-		out[4] = ax * qw + aw * qx + ay * qz - az * qy;
-		out[5] = ay * qw + aw * qy + az * qx - ax * qz;
-		out[6] = az * qw + aw * qz + ax * qy - ay * qx;
-		out[7] = aw * qw - ax * qx - ay * qy - az * qz;
-		return out;
-	}
 
-	//Rotates a dual quat by a given quaternion (q * a)
-	static rotateByQuatPrepend(out,q,a){
-		var qx = q[0], qy = q[1], qz = q[2], qw = q[3],
-		bx = a[0], by = a[1], bz = a[2], bw = a[3];
-
-		out[0] = qx * bw + qw * bx + qy * bz - qz * by;
-		out[1] = qy * bw + qw * by + qz * bx - qx * bz;
-		out[2] = qz * bw + qw * bz + qx * by - qy * bx;
-		out[3] = qw * bw - qx * bx - qy * by - qz * bz;
-
-		bx = a[4]; by = a[5]; bz = a[6]; bw = a[7];
-		out[4] = qx * bw + qw * bx + qy * bz - qz * by;
-		out[5] = qy * bw + qw * by + qz * bx - qx * bz;
-		out[6] = qz * bw + qw * bz + qx * by - qy * bx;
-		out[7] = qw * bw - qx * bx - qy * by - qz * bz;
-		return out;
-	}
+	////////////////////////////////////////////////////////////////////
+	// STATIC TRANSFORMATIONS
+	////////////////////////////////////////////////////////////////////
+
+		//Translates a dual quat by the given vector
+		static translate(out,a,v){
+			var ax1 = a[0], ay1 = a[1], az1 = a[2], aw1 = a[3],
+				ax2 = a[4], ay2 = a[5], az2 = a[6], aw2 = a[7],
+				bx1 = v[0] * 0.5, by1 = v[1] * 0.5, bz1 = v[2] * 0.5;
+
+			out[0] = ax1;
+			out[1] = ay1;
+			out[2] = az1;
+			out[3] = aw1;
+			out[4] =  aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2;
+			out[5] =  aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2;
+			out[6] =  aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2;
+			out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2;
+			return out;
+		}
 
-	//Rotates a dual quat around a given axis. Does the normalisation automatically
-	static rotateAroundAxis(out,a,axis,rad){
-		//Special case for rad = 0
-		if(Math.abs(rad) < glMatrix.EPSILON){ return dualquat.copy(out, a); } //TODO VOR- get Epsilon
+		//Rotates a dual quat around the X axis
+		static rotateX(out,a,rad){
+			var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
+				ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
+			//Trans
+			var ax1 = ax * bw + aw * bx + ay * bz - az * by,
+			ay1 = ay * bw + aw * by + az * bx - ax * bz,
+			az1 = az * bw + aw * bz + ax * by - ay * bx,
+			aw1 = aw * bw - ax * bx - ay * by - az * bz;
+
+			//Rotate it 
+			quat.rotateX(out, a, rad);
+
+			bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
+			out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
+			out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
+			out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
+			out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
+			return out;
+		}
 
-		var axisLength = Math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
+		static rotateY(out,a,rad){
+			var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
+				ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
+			
+			//Trans
+			var ax1 = ax * bw + aw * bx + ay * bz - az * by,
+			ay1 = ay * bw + aw * by + az * bx - ax * bz,
+			az1 = az * bw + aw * bz + ax * by - ay * bx,
+			aw1 = aw * bw - ax * bx - ay * by - az * bz;
+
+			//Rotate it 
+			quat.rotateY(out, a, rad);
+
+			bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
+			out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
+			out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
+			out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
+			out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
+			return out;
+		}
 
-		rad = rad * 0.5;
-		var s = Math.sin(rad);
-		var bx = s * axis[0] / axisLength;
-		var by = s * axis[1] / axisLength;
-		var bz = s * axis[2] / axisLength;
-		var bw = Math.cos(rad);
+		static rotateZ(out,a,rad){
+			//Get the translation
+			var bx = -a[0], by = -a[1], bz = -a[2], bw = a[3],
+			ax =  a[4], ay =  a[5], az =  a[6], aw = a[7];
 
-		var ax1 = a[0], ay1 = a[1], az1 = a[2], aw1 = a[3];
-		out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
-		out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
-		out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
-		out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
+			//Trans
+			var ax1 = ax * bw + aw * bx + ay * bz - az * by,
+			ay1 = ay * bw + aw * by + az * bx - ax * bz,
+			az1 = az * bw + aw * bz + ax * by - ay * bx,
+			aw1 = aw * bw - ax * bx - ay * by - az * bz;
+
+			//Rotate it 
+			quat.rotateZ(out, a, rad);
+
+			bx = out[0]; by = out[1]; bz = out[2]; bw = out[3];
+			out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
+			out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
+			out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
+			out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
+			return out;
+		}
 
-		var ax = a[4], ay = a[5], az = a[6], aw = a[7];
-		out[4] = ax * bw + aw * bx + ay * bz - az * by;
-		out[5] = ay * bw + aw * by + az * bx - ax * bz;
-		out[6] = az * bw + aw * bz + ax * by - ay * bx;
-		out[7] = aw * bw - ax * bx - ay * by - az * bz;
+		//Rotates a dual quat by a given quaternion (a * q)
+		static rotateByQuatAppend(out,a,q){
+			var qx = q[0], qy = q[1], qz = q[2], qw = q[3],
+				ax = a[0], ay = a[1], az = a[2], aw = a[3];
+
+			out[0] = ax * qw + aw * qx + ay * qz - az * qy;
+			out[1] = ay * qw + aw * qy + az * qx - ax * qz;
+			out[2] = az * qw + aw * qz + ax * qy - ay * qx;
+			out[3] = aw * qw - ax * qx - ay * qy - az * qz;
+			
+			ax = a[4]; ay = a[5]; az = a[6]; aw = a[7];
+			out[4] = ax * qw + aw * qx + ay * qz - az * qy;
+			out[5] = ay * qw + aw * qy + az * qx - ax * qz;
+			out[6] = az * qw + aw * qz + ax * qy - ay * qx;
+			out[7] = aw * qw - ax * qx - ay * qy - az * qz;
+			return out;
+		}
 
-		return out;
-	}
+		//Rotates a dual quat by a given quaternion (q * a)
+		static rotateByQuatPrepend(out,q,a){
+			var qx = q[0], qy = q[1], qz = q[2], qw = q[3],
+			bx = a[0], by = a[1], bz = a[2], bw = a[3];
+
+			out[0] = qx * bw + qw * bx + qy * bz - qz * by;
+			out[1] = qy * bw + qw * by + qz * bx - qx * bz;
+			out[2] = qz * bw + qw * bz + qx * by - qy * bx;
+			out[3] = qw * bw - qx * bx - qy * by - qz * bz;
+
+			bx = a[4]; by = a[5]; bz = a[6]; bw = a[7];
+			out[4] = qx * bw + qw * bx + qy * bz - qz * by;
+			out[5] = qy * bw + qw * by + qz * bx - qx * bz;
+			out[6] = qz * bw + qw * bz + qx * by - qy * bx;
+			out[7] = qw * bw - qx * bx - qy * by - qz * bz;
+			return out;
+		}
 
-	static transformVec3(dq, va, out = null){
-		let pos	= DualQuat.getTranslation( dq );
-		out		= out || new Vec3();
+		//Rotates a dual quat around a given axis. Does the normalisation automatically
+		static rotateAroundAxis(out,a,axis,rad){
+			//Special case for rad = 0
+			if(Math.abs(rad) < glMatrix.EPSILON){ return dualquat.copy(out, a); } //TODO VOR- get Epsilon
+
+			var axisLength = Math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
+
+			rad = rad * 0.5;
+			var s = Math.sin(rad);
+			var bx = s * axis[0] / axisLength;
+			var by = s * axis[1] / axisLength;
+			var bz = s * axis[2] / axisLength;
+			var bw = Math.cos(rad);
+
+			var ax1 = a[0], ay1 = a[1], az1 = a[2], aw1 = a[3];
+			out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;
+			out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;
+			out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;
+			out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;
+
+			var ax = a[4], ay = a[5], az = a[6], aw = a[7];
+			out[4] = ax * bw + aw * bx + ay * bz - az * by;
+			out[5] = ay * bw + aw * by + az * bx - ax * bz;
+			out[6] = az * bw + aw * bz + ax * by - ay * bx;
+			out[7] = aw * bw - ax * bx - ay * by - az * bz;
+
+			return out;
+		}
 
-		Vec3.transformQuat(va, dq, out);
-		out[0] += pos[0];
-		out[1] += pos[1];
-		out[2] += pos[2];
 
-		return out;
-	}
 /*
 	static lerp(a, b, t, out){
 		let mt = 1 - t;
diff --git a/fungi/maths/Mat4.js b/fungi/maths/Mat4.js
index 9acbef8..d2f49e9 100644
--- a/fungi/maths/Mat4.js
+++ b/fungi/maths/Mat4.js
@@ -1,8 +1,9 @@
 class Matrix4 extends Float32Array{
 	constructor(){ super(16); this[0] = this[5] = this[10] = this[15] = 1; }  //Setup Identity
 
-	//----------------------------------------------
-	//region Methods
+	////////////////////////////////////////////////////////////////////
+	// METHODS
+	////////////////////////////////////////////////////////////////////
 		translate(ary){	Matrix4.translate(this,ary[0],ary[1],ary[2]); return this;}
 		resetTranslation(){ this[12] = this[13] = this[14] = 0; this[15] = 1; return this; }
 
@@ -17,10 +18,11 @@ class Matrix4 extends Float32Array{
 			for(var i=0; i < 16; i++) this[i] = mat[i];
 			return this;
 		}
-	//endregion
 
-	//----------------------------------------------
-	//region Static
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC SETTERS
+	////////////////////////////////////////////////////////////////////
 		static identity(out){
 			for(var i=0; i <= out.length; i++) out[i] = (i % 5 == 0)? 1 : 0; //only positions 0,5,10,15 need to be 1 else 0
 		}
@@ -66,7 +68,240 @@ class Matrix4 extends Float32Array{
 			out[13] = (top + bottom) * bt;
 			out[14] = (far + near) * nf;
 			out[15] = 1;
-		};
+		}
+
+		//This creates a View Matrix, not a World Matrix. Use TargetTo for a World Matrix type LookAt.
+		static lookAt(eye, center, up, out){
+			let x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
+			let eyex = eye[0];
+			let eyey = eye[1];
+			let eyez = eye[2];
+			let upx = up[0];
+			let upy = up[1];
+			let upz = up[2];
+			let centerx = center[0];
+			let centery = center[1];
+			let centerz = center[2];
+
+			if (Math.abs(eyex - centerx) < 0.000001 &&
+				Math.abs(eyey - centery) < 0.000001 &&
+				Math.abs(eyez - centerz) < 0.000001) {
+				return identity(out);
+			}
+
+			z0 = eyex - centerx;
+			z1 = eyey - centery;
+			z2 = eyez - centerz;
+
+			len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+			z0 *= len;
+			z1 *= len;
+			z2 *= len;
+
+			x0 = upy * z2 - upz * z1;
+			x1 = upz * z0 - upx * z2;
+			x2 = upx * z1 - upy * z0;
+			len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+
+			if (!len) {
+				x0 = 0;
+				x1 = 0;
+				x2 = 0;
+			} else {
+				len = 1 / len;
+				x0 *= len;
+				x1 *= len;
+				x2 *= len;
+			}
+
+			y0 = z1 * x2 - z2 * x1;
+			y1 = z2 * x0 - z0 * x2;
+			y2 = z0 * x1 - z1 * x0;
+
+			len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+			if (!len) {
+				y0 = 0;
+				y1 = 0;
+				y2 = 0;
+			} else {
+				len = 1 / len;
+				y0 *= len;
+				y1 *= len;
+				y2 *= len;
+			}
+
+			out[0] = x0;
+			out[1] = y0;
+			out[2] = z0;
+			out[3] = 0;
+			out[4] = x1;
+			out[5] = y1;
+			out[6] = z1;
+			out[7] = 0;
+			out[8] = x2;
+			out[9] = y2;
+			out[10] = z2;
+			out[11] = 0;
+			out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+			out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+			out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+			out[15] = 1;
+
+			return out;
+		}
+
+		static targetTo(eye, target, up, out){
+			let eyex = eye[0],
+				eyey = eye[1],
+				eyez = eye[2],
+				upx = up[0],
+				upy = up[1],
+				upz = up[2];
+
+			let z0 = eyex - target[0],
+				z1 = eyey - target[1],
+				z2 = eyez - target[2];
+
+			let len = z0*z0 + z1*z1 + z2*z2;
+			if (len > 0) {
+				len = 1 / Math.sqrt(len);
+				z0 *= len;
+				z1 *= len;
+				z2 *= len;
+			}
+
+			let x0 = upy * z2 - upz * z1,
+				x1 = upz * z0 - upx * z2,
+				x2 = upx * z1 - upy * z0;
+
+			len = x0*x0 + x1*x1 + x2*x2;
+			if (len > 0) {
+				len = 1 / Math.sqrt(len);
+				x0 *= len;
+				x1 *= len;
+				x2 *= len;
+			}
+
+			out[0] = x0;
+			out[1] = x1;
+			out[2] = x2;
+			out[3] = 0;
+			out[4] = z1 * x2 - z2 * x1;
+			out[5] = z2 * x0 - z0 * x2;
+			out[6] = z0 * x1 - z1 * x0;
+			out[7] = 0;
+			out[8] = z0;
+			out[9] = z1;
+			out[10] = z2;
+			out[11] = 0;
+			out[12] = eyex;
+			out[13] = eyey;
+			out[14] = eyez;
+			out[15] = 1;
+			return out;
+		}
+
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC CONVERSIONS
+	////////////////////////////////////////////////////////////////////
+
+		//Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
+		static normalMat3( a, out ){
+			var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
+				a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
+				a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
+				a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15],
+
+				b00 = a00 * a11 - a01 * a10,
+				b01 = a00 * a12 - a02 * a10,
+				b02 = a00 * a13 - a03 * a10,
+				b03 = a01 * a12 - a02 * a11,
+				b04 = a01 * a13 - a03 * a11,
+				b05 = a02 * a13 - a03 * a12,
+				b06 = a20 * a31 - a21 * a30,
+				b07 = a20 * a32 - a22 * a30,
+				b08 = a20 * a33 - a23 * a30,
+				b09 = a21 * a32 - a22 * a31,
+				b10 = a21 * a33 - a23 * a31,
+				b11 = a22 * a33 - a23 * a32,
+
+			// Calculate the determinant
+			det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
+
+			if (!det) return null;
+
+			det = 1.0 / det;
+
+			out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
+			out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+			out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+
+			out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+			out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+			out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+
+			out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+			out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+			out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+			return out;
+		}
+
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC OPERATIONS
+	////////////////////////////////////////////////////////////////////
+
+		//From glMatrix
+		//Multiple two mat4 together
+		static mul( a, b, out ){ 
+			var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
+				a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
+				a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
+				a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
+
+			// Cache only the current line of the second matrix
+			var b0  = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
+			out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+			out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+			out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+			out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+			b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7];
+			out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+			out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+			out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+			out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+			b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11];
+			out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+			out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+			out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+			out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+
+			b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15];
+			out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
+			out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
+			out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
+			out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+			return out;	
+		}
+
+		static scale(out,x,y,z){
+			out[0] *= x;
+			out[1] *= x;
+			out[2] *= x;
+			out[3] *= x;
+			out[4] *= y;
+			out[5] *= y;
+			out[6] *= y;
+			out[7] *= y;
+			out[8] *= z;
+			out[9] *= z;
+			out[10] *= z;
+			out[11] *= z;
+			return out;
+		}
 
 		//make the rows into the columns
 		static transpose( a, out ){
@@ -107,12 +342,13 @@ class Matrix4 extends Float32Array{
 			return out;
 		}
 
-		//Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
-		static normalMat3( a, out ){
-			var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
-				a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
-				a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
-				a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15],
+		static invert( mat, out ) {
+			mat = mat || out; //If input isn't sent, then output is also input
+
+			var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3],
+				a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7],
+				a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11],
+				a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15],
 
 				b00 = a00 * a11 - a01 * a10,
 				b01 = a00 * a12 - a02 * a10,
@@ -127,27 +363,76 @@ class Matrix4 extends Float32Array{
 				b10 = a21 * a33 - a23 * a31,
 				b11 = a22 * a33 - a23 * a32,
 
-			// Calculate the determinant
-			det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-
-			if (!det) return null;
+				// Calculate the determinant
+				det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
 
+			if (!det) return false;
 			det = 1.0 / det;
 
 			out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
-			out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
-			out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+			out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
+			out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
+			out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
+			out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
+			out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
+			out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
+			out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
+			out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
+			out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+			out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+			out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
+			out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
+			out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
+			out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
+			out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
 
-			out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
-			out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
-			out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
+			return true;
+		}
 
-			out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
-			out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
-			out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
+		//https://github.com/gregtatum/mdn-model-view-projection/blob/master/shared/matrices.js
+		static multiplyVector(mat4, v) { //TODO: Dont need this, transformVec3 does a better job.
+			var x = v[0], y = v[1], z = v[2], w = v[3];
+			var c1r1 = mat4[ 0], c2r1 = mat4[ 1], c3r1 = mat4[ 2], c4r1 = mat4[ 3],
+				c1r2 = mat4[ 4], c2r2 = mat4[ 5], c3r2 = mat4[ 6], c4r2 = mat4[ 7],
+				c1r3 = mat4[ 8], c2r3 = mat4[ 9], c3r3 = mat4[10], c4r3 = mat4[11],
+				c1r4 = mat4[12], c2r4 = mat4[13], c3r4 = mat4[14], c4r4 = mat4[15];
+
+			return [
+				x*c1r1 + y*c1r2 + z*c1r3 + w*c1r4,
+				x*c2r1 + y*c2r2 + z*c2r3 + w*c2r4,
+				x*c3r1 + y*c3r2 + z*c3r3 + w*c3r4,
+				x*c4r1 + y*c4r2 + z*c4r3 + w*c4r4
+			];
+		}
+
+		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/vec4.js, vec4.transformMat4
+		static transformVec4(m, v, out = null){
+			var x = v[0], y = v[1], z = v[2], w = v[3];
+			out = out || v;
+
+			out[0] = m[0] * x + m[4] * y + m[8]		* z + m[12] * w;
+			out[1] = m[1] * x + m[5] * y + m[9]		* z + m[13] * w;
+			out[2] = m[2] * x + m[6] * y + m[10]	* z + m[14] * w;
+			out[3] = m[3] * x + m[7] * y + m[11]	* z + m[15] * w;
 			return out;
 		}
 
+		static transformVec3(m, v, out = null){
+			var x = v[0], y = v[1], z = v[2];
+
+			out = out || v;
+			out[0] = m[0] * x + m[4] * y + m[8]		* z + m[12];
+			out[1] = m[1] * x + m[5] * y + m[9]		* z + m[13];
+			out[2] = m[2] * x + m[6] * y + m[10]	* z + m[14];
+			out[3] = m[3] * x + m[7] * y + m[11]	* z + m[15];
+			return out;
+		}
+
+		
+	////////////////////////////////////////////////////////////////////
+	// STATIC GETTER / SETTER
+	////////////////////////////////////////////////////////////////////
+
 		//New function derived from fromRotationTranslation, just took out the translation stuff.
 		static fromQuaternion( q, out ){
 			// Quaternion math
@@ -255,161 +540,71 @@ class Matrix4 extends Float32Array{
 			out[14] = v[2];
 			out[15] = 1;
 
-			return out;
-		}
-
-		static getTranslation(out, mat){
-			out[0] = mat[12];
-			out[1] = mat[13];
-			out[2] = mat[14];
-			return out;
-		}
-
-		static getScaling(out, mat){
-			var m11 = mat[0],
-				m12 = mat[1],
-				m13 = mat[2],
-				m21 = mat[4],
-				m22 = mat[5],
-				m23 = mat[6],
-				m31 = mat[8],
-				m32 = mat[9],
-				m33 = mat[10];
-			out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
-			out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
-			out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
-			return out;
-		}
-
-		//Returns a quaternion representing the rotational component of a transformation matrix. If a matrix is built with
-		//fromRotationTranslation, the returned quaternion will be the same as the quaternion originally supplied
-		static getRotation(out, mat){
-			// Algorithm taken from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
-			var trace = mat[0] + mat[5] + mat[10],
-				S = 0;
-
-			if(trace > 0){
-				S = Math.sqrt(trace + 1.0) * 2;
-				out[3] = 0.25 * S;
-				out[0] = (mat[6] - mat[9]) / S;
-				out[1] = (mat[8] - mat[2]) / S; 
-				out[2] = (mat[1] - mat[4]) / S; 
-			}else if( (mat[0] > mat[5]) & (mat[0] > mat[10]) ){ 
-				S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2;
-				out[3] = (mat[6] - mat[9]) / S;
-				out[0] = 0.25 * S;
-				out[1] = (mat[1] + mat[4]) / S; 
-				out[2] = (mat[8] + mat[2]) / S; 
-			}else if(mat[5] > mat[10]){ 
-				S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2;
-				out[3] = (mat[8] - mat[2]) / S;
-				out[0] = (mat[1] + mat[4]) / S; 
-				out[1] = 0.25 * S;
-				out[2] = (mat[6] + mat[9]) / S; 
-			}else{ 
-				S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2;
-				out[3] = (mat[1] - mat[4]) / S;
-				out[0] = (mat[8] + mat[2]) / S;
-				out[1] = (mat[6] + mat[9]) / S;
-				out[2] = 0.25 * S;
-			}
-			return out;
-		}
-
-		//....................................................................
-		//Static Operation
-
-		//https://github.com/gregtatum/mdn-model-view-projection/blob/master/shared/matrices.js
-		static multiplyVector(mat4, v) { //TODO: Dont need this, transformVec3 does a better job.
-			var x = v[0], y = v[1], z = v[2], w = v[3];
-			var c1r1 = mat4[ 0], c2r1 = mat4[ 1], c3r1 = mat4[ 2], c4r1 = mat4[ 3],
-				c1r2 = mat4[ 4], c2r2 = mat4[ 5], c3r2 = mat4[ 6], c4r2 = mat4[ 7],
-				c1r3 = mat4[ 8], c2r3 = mat4[ 9], c3r3 = mat4[10], c4r3 = mat4[11],
-				c1r4 = mat4[12], c2r4 = mat4[13], c3r4 = mat4[14], c4r4 = mat4[15];
-
-			return [
-				x*c1r1 + y*c1r2 + z*c1r3 + w*c1r4,
-				x*c2r1 + y*c2r2 + z*c2r3 + w*c2r4,
-				x*c3r1 + y*c3r2 + z*c3r3 + w*c3r4,
-				x*c4r1 + y*c4r2 + z*c4r3 + w*c4r4
-			];
-		}
-
-		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/vec4.js, vec4.transformMat4
-		static transformVec4(m, v, out = null){
-			var x = v[0], y = v[1], z = v[2], w = v[3];
-			out = out || v;
-
-			out[0] = m[0] * x + m[4] * y + m[8]		* z + m[12] * w;
-			out[1] = m[1] * x + m[5] * y + m[9]		* z + m[13] * w;
-			out[2] = m[2] * x + m[6] * y + m[10]	* z + m[14] * w;
-			out[3] = m[3] * x + m[7] * y + m[11]	* z + m[15] * w;
-			return out;
-		}
-
-		static transformVec3(m, v, out = null){
-			var x = v[0], y = v[1], z = v[2];
-
-			out = out || v;
-			out[0] = m[0] * x + m[4] * y + m[8]		* z + m[12];
-			out[1] = m[1] * x + m[5] * y + m[9]		* z + m[13];
-			out[2] = m[2] * x + m[6] * y + m[10]	* z + m[14];
-			out[3] = m[3] * x + m[7] * y + m[11]	* z + m[15];
-			return out;
-		}
-
-		//From glMatrix
-		//Multiple two mat4 together
-		static mul( a, b, out ){ 
-			var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3],
-				a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7],
-				a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11],
-				a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15];
-
-			// Cache only the current line of the second matrix
-			var b0  = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
-			out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
-			out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
-			out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
-			out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
-
-			b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7];
-			out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
-			out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
-			out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
-			out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
-
-			b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11];
-			out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
-			out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
-			out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
-			out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
+			return out;
+		}
 
-			b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15];
-			out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30;
-			out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31;
-			out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32;
-			out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33;
-			return out;	
+		static getTranslation(out, mat){
+			out[0] = mat[12];
+			out[1] = mat[13];
+			out[2] = mat[14];
+			return out;
 		}
 
-		//....................................................................
-		//Static Transformation
-		static scale(out,x,y,z){
-			out[0] *= x;
-			out[1] *= x;
-			out[2] *= x;
-			out[3] *= x;
-			out[4] *= y;
-			out[5] *= y;
-			out[6] *= y;
-			out[7] *= y;
-			out[8] *= z;
-			out[9] *= z;
-			out[10] *= z;
-			out[11] *= z;
+		static getScaling(out, mat){
+			var m11 = mat[0],
+				m12 = mat[1],
+				m13 = mat[2],
+				m21 = mat[4],
+				m22 = mat[5],
+				m23 = mat[6],
+				m31 = mat[8],
+				m32 = mat[9],
+				m33 = mat[10];
+			out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+			out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+			out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+			return out;
+		}
+
+		//Returns a quaternion representing the rotational component of a transformation matrix. If a matrix is built with
+		//fromRotationTranslation, the returned quaternion will be the same as the quaternion originally supplied
+		static getRotation(out, mat){
+			// Algorithm taken from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+			var trace = mat[0] + mat[5] + mat[10],
+				S = 0;
+
+			if(trace > 0){
+				S = Math.sqrt(trace + 1.0) * 2;
+				out[3] = 0.25 * S;
+				out[0] = (mat[6] - mat[9]) / S;
+				out[1] = (mat[8] - mat[2]) / S; 
+				out[2] = (mat[1] - mat[4]) / S; 
+			}else if( (mat[0] > mat[5]) & (mat[0] > mat[10]) ){ 
+				S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2;
+				out[3] = (mat[6] - mat[9]) / S;
+				out[0] = 0.25 * S;
+				out[1] = (mat[1] + mat[4]) / S; 
+				out[2] = (mat[8] + mat[2]) / S; 
+			}else if(mat[5] > mat[10]){ 
+				S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2;
+				out[3] = (mat[8] - mat[2]) / S;
+				out[0] = (mat[1] + mat[4]) / S; 
+				out[1] = 0.25 * S;
+				out[2] = (mat[6] + mat[9]) / S; 
+			}else{ 
+				S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2;
+				out[3] = (mat[1] - mat[4]) / S;
+				out[0] = (mat[8] + mat[2]) / S;
+				out[1] = (mat[6] + mat[9]) / S;
+				out[2] = 0.25 * S;
+			}
 			return out;
-		};
+		}
+
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC TRANSFORMATION
+	////////////////////////////////////////////////////////////////////
 
 		static rotateY(out,rad) {
 			var s = Math.sin(rad),
@@ -529,53 +724,6 @@ class Matrix4 extends Float32Array{
 			out[11] = a03 * b20 + a13 * b21 + a23 * b22;
 		}
 
-		static invert( mat, out ) {
-			mat = mat || out; //If input isn't sent, then output is also input
-
-			var a00 = mat[0], a01 = mat[1], a02 = mat[2], a03 = mat[3],
-				a10 = mat[4], a11 = mat[5], a12 = mat[6], a13 = mat[7],
-				a20 = mat[8], a21 = mat[9], a22 = mat[10], a23 = mat[11],
-				a30 = mat[12], a31 = mat[13], a32 = mat[14], a33 = mat[15],
-
-				b00 = a00 * a11 - a01 * a10,
-				b01 = a00 * a12 - a02 * a10,
-				b02 = a00 * a13 - a03 * a10,
-				b03 = a01 * a12 - a02 * a11,
-				b04 = a01 * a13 - a03 * a11,
-				b05 = a02 * a13 - a03 * a12,
-				b06 = a20 * a31 - a21 * a30,
-				b07 = a20 * a32 - a22 * a30,
-				b08 = a20 * a33 - a23 * a30,
-				b09 = a21 * a32 - a22 * a31,
-				b10 = a21 * a33 - a23 * a31,
-				b11 = a22 * a33 - a23 * a32,
-
-				// Calculate the determinant
-				det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
-
-			if (!det) return false;
-			det = 1.0 / det;
-
-			out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;
-			out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;
-			out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;
-			out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;
-			out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;
-			out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;
-			out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;
-			out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;
-			out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;
-			out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;
-			out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;
-			out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;
-			out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;
-			out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;
-			out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;
-			out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
-
-			return true;
-		}
-
 		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/mat4.js  mat4.scalar.translate = function (out, a, v) {
 		static translate(out,x,y,z){
 			out[12] = out[0] * x + out[4] * y + out[8]	* z + out[12];
@@ -583,140 +731,6 @@ class Matrix4 extends Float32Array{
 			out[14] = out[2] * x + out[6] * y + out[10]	* z + out[14];
 			out[15] = out[3] * x + out[7] * y + out[11]	* z + out[15];
 		}
-
-
-		//This creates a View Matrix, not a World Matrix. Use TargetTo for a World Matrix type LookAt.
-		static lookAt(eye, center, up, out){
-			let x0, x1, x2, y0, y1, y2, z0, z1, z2, len;
-			let eyex = eye[0];
-			let eyey = eye[1];
-			let eyez = eye[2];
-			let upx = up[0];
-			let upy = up[1];
-			let upz = up[2];
-			let centerx = center[0];
-			let centery = center[1];
-			let centerz = center[2];
-
-			if (Math.abs(eyex - centerx) < 0.000001 &&
-				Math.abs(eyey - centery) < 0.000001 &&
-				Math.abs(eyez - centerz) < 0.000001) {
-				return identity(out);
-			}
-
-			z0 = eyex - centerx;
-			z1 = eyey - centery;
-			z2 = eyez - centerz;
-
-			len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
-			z0 *= len;
-			z1 *= len;
-			z2 *= len;
-
-			x0 = upy * z2 - upz * z1;
-			x1 = upz * z0 - upx * z2;
-			x2 = upx * z1 - upy * z0;
-			len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
-
-			if (!len) {
-				x0 = 0;
-				x1 = 0;
-				x2 = 0;
-			} else {
-				len = 1 / len;
-				x0 *= len;
-				x1 *= len;
-				x2 *= len;
-			}
-
-			y0 = z1 * x2 - z2 * x1;
-			y1 = z2 * x0 - z0 * x2;
-			y2 = z0 * x1 - z1 * x0;
-
-			len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
-			if (!len) {
-				y0 = 0;
-				y1 = 0;
-				y2 = 0;
-			} else {
-				len = 1 / len;
-				y0 *= len;
-				y1 *= len;
-				y2 *= len;
-			}
-
-			out[0] = x0;
-			out[1] = y0;
-			out[2] = z0;
-			out[3] = 0;
-			out[4] = x1;
-			out[5] = y1;
-			out[6] = z1;
-			out[7] = 0;
-			out[8] = x2;
-			out[9] = y2;
-			out[10] = z2;
-			out[11] = 0;
-			out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
-			out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
-			out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
-			out[15] = 1;
-
-			return out;
-		}
-
-		static targetTo(eye, target, up, out){
-			let eyex = eye[0],
-				eyey = eye[1],
-				eyez = eye[2],
-				upx = up[0],
-				upy = up[1],
-				upz = up[2];
-
-			let z0 = eyex - target[0],
-				z1 = eyey - target[1],
-				z2 = eyez - target[2];
-
-			let len = z0*z0 + z1*z1 + z2*z2;
-			if (len > 0) {
-				len = 1 / Math.sqrt(len);
-				z0 *= len;
-				z1 *= len;
-				z2 *= len;
-			}
-
-			let x0 = upy * z2 - upz * z1,
-				x1 = upz * z0 - upx * z2,
-				x2 = upx * z1 - upy * z0;
-
-			len = x0*x0 + x1*x1 + x2*x2;
-			if (len > 0) {
-				len = 1 / Math.sqrt(len);
-				x0 *= len;
-				x1 *= len;
-				x2 *= len;
-			}
-
-			out[0] = x0;
-			out[1] = x1;
-			out[2] = x2;
-			out[3] = 0;
-			out[4] = z1 * x2 - z2 * x1;
-			out[5] = z2 * x0 - z0 * x2;
-			out[6] = z0 * x1 - z1 * x0;
-			out[7] = 0;
-			out[8] = z0;
-			out[9] = z1;
-			out[10] = z2;
-			out[11] = 0;
-			out[12] = eyex;
-			out[13] = eyey;
-			out[14] = eyez;
-			out[15] = 1;
-			return out;
-		};
-
-	//endregion
 }
 
 export default Matrix4
\ No newline at end of file
diff --git a/fungi/maths/Maths.js b/fungi/maths/Maths.js
index 0891f50..13fea04 100644
--- a/fungi/maths/Maths.js
+++ b/fungi/maths/Maths.js
@@ -1,6 +1,6 @@
-import Vec3		from "./maths/Vec3.js";
-import Mat4		from "./maths/Mat4.js";
-import Quat		from "./maths/Quat.js";
+import Vec3		from "./Vec3.js";
+import Mat4		from "./Mat4.js";
+import Quat		from "./Quat.js";
 
 // +++NOTES+++
 // How to increment but still get 0 or 1 value by using bitwie AND and checking for 1
diff --git a/fungi/maths/Quat.js b/fungi/maths/Quat.js
index 120f106..99a5421 100644
--- a/fungi/maths/Quat.js
+++ b/fungi/maths/Quat.js
@@ -1,43 +1,7 @@
 import Vec3 from "./Vec3.js";
 
-//https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/math/Quaternion.java
-//http://physicsforgames.blogspot.com/2010/03/quaternion-tricks.html
-//http://physicsforgames.blogspot.com/2010/02/quaternions.html
-/*
-Here is a function that will give you the rotation quaternion that will rotate some initial vector into some final vector
-Quat getRotationQuat(const Vector& from, const Vector& to)
-{
-     Quat result;
-
-     Vector H = VecAdd(from, to);
-     H = VecNormalize(H);
-
-     result.w = VecDot(from, H);
-     result.x = from.y*H.z - from.z*H.y;
-     result.y = from.z*H.x - from.x*H.z;
-     result.z = from.x*H.y - from.y*H.x;
-     return result;
-}
-
-Vector rotateVector(const Vector& v, const Quat& q)
-{
-     Vector result;
-     float x1 = q.y*v.z - q.z*v.y;
-     float y1 = q.z*v.x - q.x*v.z;
-     float z1 = q.x*v.y - q.y*v.x;
-
-     float x2 = q.w*x1 + q.y*z1 - q.z*y1;
-     float y2 = q.w*y1 + q.z*x1 - q.x*z1;
-     float z2 = q.w*z1 + q.x*y1 - q.y*x1;
-
-     result.x = v.x + 2.0f*x2;
-     result.y = v.y + 2.0f*y2;
-     result.z = v.z + 2.0f*z2;
-
-     return result;
-}
-*/
-
+// http://in2gpu.com/2016/03/14/opengl-fps-camera-quaternion/
+// https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
 
 class Quaternion extends Float32Array{
 	constructor(q = null){
@@ -54,10 +18,9 @@ class Quaternion extends Float32Array{
 	}
 
 
-	//http://in2gpu.com/2016/03/14/opengl-fps-camera-quaternion/
-	//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
-	//----------------------------------------------
-	//region Setter/Getters
+	////////////////////////////////////////////////////////////////////
+	// GETTER - SETTERS
+	////////////////////////////////////////////////////////////////////
 		reset(){ this[0] = this[1] = this[2] = 0; this[3] = 1; return this; }
 
 		get x(){ return this[0]; }	set x(val){ this[0] = val; }
@@ -120,11 +83,11 @@ class Quaternion extends Float32Array{
 		}
 
 		clone(){ return new Quaternion(this); }
-	//endregion
-	
 
-	//----------------------------------------------
-	//region
+
+	////////////////////////////////////////////////////////////////////
+	// INSTANCE OPERATIONS
+	////////////////////////////////////////////////////////////////////
 		normalize(out = null){
 			var len =  this[0]*this[0] + this[1]*this[1] + this[2]*this[2] + this[3]*this[3];
 			out = out || this;
@@ -185,60 +148,11 @@ class Quaternion extends Float32Array{
 			out[3]	=  a3 * invDot;
 			return out;
 		}
-	//endregion
-
-
-	//----------------------------------------------
-	//region Static Methods
-		static dot( a, b ){
-  			return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-		}
 
-		static mul( a, b, out ){
-			var ax = a[0], ay = a[1], az = a[2], aw = a[3],
-				bx = b[0], by = b[1], bz = b[2], bw = b[3];
-
-			out[0] = ax * bw + aw * bx + ay * bz - az * by;
-			out[1] = ay * bw + aw * by + az * bx - ax * bz;
-			out[2] = az * bw + aw * bz + ax * by - ay * bx;
-			out[3] = aw * bw - ax * bx - ay * by - az * bz;
-			return out;
-		}
 
-		/* Doesn't seem to work well to rotate a vector
-		static mulVec3(q, v, out=null){
-			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
-				bx = v[0], by = v[1], bz = v[2];
-
-			out = out || new Vec3();
-			out[0] = ax + aw * bx + ay * bz - az * by;
-			out[1] = ay + aw * by + az * bx - ax * bz;
-			out[2] = az + aw * bz + ax * by - ay * bx;
-			return out;
-		} */
-
-		static rotateVec3( qa, va, out = null ){
-			//https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaternion
-			//vprime = 2.0f * dot(u, v) * u
-			//			+ (s*s - dot(u, u)) * v
-			//			+ 2.0f * s * cross(u, v);
-			var q = [qa[0],qa[1],qa[2]],		//Save the vector part of the Quaternion
-				v = [va[0],va[1],va[2]],		//Make a copy of the vector, going to chg its value
-				s = qa[3],						//Save Quaternion Scalar (W)
-				d = Vec3.dot(q,v),	// U DOT V
-				dq = Vec3.dot(q,q),	// U DOT U
-				cqv = Vec3.cross(q,v,[0,0,0]);	// Cross Product for Q,V
-
-			Vec3.scale(q,	2.0 * d,	q);
-			Vec3.scale(v,	s*s - dq,	v);
-			Vec3.scale(cqv,	2.0 * s,	cqv);
-
-			out = out || new Vec3();
-			out[0] = q[0] + v[0] + cqv[0];
-			out[1] = q[1] + v[1] + cqv[1];
-			out[2] = q[2] + v[2] + cqv[2];
-			return out;
-		}
+	////////////////////////////////////////////////////////////////////
+	// STATIC GETTER / SETTERS
+	////////////////////////////////////////////////////////////////////
 
 		//Ported to JS from C# example at https://pastebin.com/ubATCxJY
 		//Note, if Dir and Up are equal, a roll happends. Need to find a way to fix this.
@@ -298,6 +212,46 @@ class Quaternion extends Float32Array{
 			return out;
 		}
 
+		//Using unit vectors, Shortest rotation from Direction A to Direction B
+		//http://glmatrix.net/docs/quat.js.html#line548
+		static rotationTo( a, b, out = null ){
+			let dot = Vec3.dot(a, b);
+			out = out || new Quat();
+
+		    if (dot < -0.999999) {
+		      let tmp = Vec3.cross(Vec3.LEFT, a);
+		      //if(Vec3.len(tmp) < 0.000001) Vec3.cross(Vec3.UP, a, tmp);
+		      if(tmp.length() < 0.000001) Vec3.cross(Vec3.UP, a, tmp);
+		      out.setAxisAngle( tmp.normalize(), Math.PI);
+		    }else if(dot > 0.999999){
+		      out[0] = 0;
+		      out[1] = 0;
+		      out[2] = 0;
+		      out[3] = 1;
+		    }else{
+		      let v = Vec3.cross(a, b);
+		      out[0] = v[0];
+		      out[1] = v[1];
+		      out[2] = v[2];
+		      out[3] = 1 + dot;
+		      out.normalize();
+		    }
+		    return out;
+		}
+
+		static axisAngle(axis, angle, out=null){ //AXIS MUST BE NORMALIZED.
+			let halfAngle	= angle * .5,
+				s			= Math.sin(halfAngle);
+
+			out = out || new Quaternion();
+			out[0] = axis[0] * s;
+			out[1] = axis[1] * s;
+			out[2] = axis[2] * s;
+			out[3] = Math.cos(halfAngle);
+
+			return out;
+		}
+
 		static fromAxis(xAxis, yAxis, zAxis, out = null){
 			var m00 = xAxis.x, m01 = xAxis.y, m02 = xAxis.z,
 				m10 = yAxis.x, m11 = yAxis.y, m12 = yAxis.z,
@@ -343,75 +297,39 @@ class Quaternion extends Float32Array{
 			return out;
 		}
 
-		//Using unit vectors, Shortest rotation from Direction A to Direction B
-		//http://glmatrix.net/docs/quat.js.html#line548
-		static rotationTo( a, b, out = null ){
-			let dot = Vec3.dot(a, b);
-			out = out || new Quat();
-
-		    if (dot < -0.999999) {
-		      let tmp = Vec3.cross(Vec3.LEFT, a);
-		      //if(Vec3.len(tmp) < 0.000001) Vec3.cross(Vec3.UP, a, tmp);
-		      if(tmp.length() < 0.000001) Vec3.cross(Vec3.UP, a, tmp);
-		      out.setAxisAngle( tmp.normalize(), Math.PI);
-		    }else if(dot > 0.999999){
-		      out[0] = 0;
-		      out[1] = 0;
-		      out[2] = 0;
-		      out[3] = 1;
-		    }else{
-		      let v = Vec3.cross(a, b);
-		      out[0] = v[0];
-		      out[1] = v[1];
-		      out[2] = v[2];
-		      out[3] = 1 + dot;
-		      out.normalize();
-		    }
-		    return out;
-		}
-
-
-		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
-		static rotateX(q, rad, out = null){
-			out = out || q;
-			rad *= 0.5; 
-
-			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
-				bx = Math.sin(rad), bw = Math.cos(rad);
-
-			out[0] = ax * bw + aw * bx;
-			out[1] = ay * bw + az * bx;
-			out[2] = az * bw - ay * bx;
-			out[3] = aw * bw - ax * bx;
-			return out;
-		}
-
-		static rotateY(q, rad, out = null) {
-			out = out || q;
-			rad *= 0.5; 
-
-			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
-				by = Math.sin(rad), bw = Math.cos(rad);
+		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js#L305
+		static fromMat3(m, out){
+			// Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+			// article "Quaternion Calculus and Fast Animation".
+			let fRoot, fTrace = m[0] + m[4] + m[8];
 
-			out[0] = ax * bw - az * by;
-			out[1] = ay * bw + aw * by;
-			out[2] = az * bw + ax * by;
-			out[3] = aw * bw - ay * by;
-			return out;
-		}
+			if( fTrace > 0.0 ){
+				// |w| > 1/2, may as well choose w > 1/2
+				fRoot	= Math.sqrt( fTrace + 1.0 );  // 2w
+				out[3]	= 0.5 * fRoot;
+				
+				fRoot	= 0.5 / fRoot;  // 1/(4w)
+				out[0]	= (m[5]-m[7])*fRoot;
+				out[1]	= (m[6]-m[2])*fRoot;
+				out[2]	= (m[1]-m[3])*fRoot;
+			}else{
+				// |w| <= 1/2
+				let i = 0;
 
-		static rotateZ(q, rad, out = null){
-			out = out || q;
-			rad *= 0.5; 
+				if ( m[4] > m[0] )		i = 1;
+				if ( m[8] > m[i*3+i] )	i = 2;
+				
+				let j = (i+1) % 3;
+				let k = (i+2) % 3;
 
-			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
-				bz = Math.sin(rad),
-				bw = Math.cos(rad);
+				fRoot	= Math.sqrt( m[i*3+i] - m[j*3+j] - m[k*3+k] + 1.0);
+				out[i]	= 0.5 * fRoot;
 
-			out[0] = ax * bw + ay * bz;
-			out[1] = ay * bw - ax * bz;
-			out[2] = az * bw + aw * bz;
-			out[3] = aw * bw - az * bz;
+				fRoot	= 0.5 / fRoot;
+				out[3]	= ( m[j*3+k] - m[k*3+j] ) * fRoot;
+				out[j]	= ( m[j*3+i] + m[i*3+j] ) * fRoot;
+				out[k]	= ( m[k*3+i] + m[i*3+k] ) * fRoot;
+			}
 			return out;
 		}
 
@@ -509,6 +427,93 @@ class Quaternion extends Float32Array{
 			return out;
 		}
 
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC OPERATIONS
+	////////////////////////////////////////////////////////////////////
+		
+		static mul( a, b, out ){
+			var ax = a[0], ay = a[1], az = a[2], aw = a[3],
+				bx = b[0], by = b[1], bz = b[2], bw = b[3];
+
+			out[0] = ax * bw + aw * bx + ay * bz - az * by;
+			out[1] = ay * bw + aw * by + az * bx - ax * bz;
+			out[2] = az * bw + aw * bz + ax * by - ay * bx;
+			out[3] = aw * bw - ax * bx - ay * by - az * bz;
+			return out;
+		}
+
+		static dot( a, b ){
+  			return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+		}
+
+		static rotateVec3( qa, va, out = null ){
+			//https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaternion
+			//vprime = 2.0f * dot(u, v) * u
+			//			+ (s*s - dot(u, u)) * v
+			//			+ 2.0f * s * cross(u, v);
+			var q = [qa[0],qa[1],qa[2]],		//Save the vector part of the Quaternion
+				v = [va[0],va[1],va[2]],		//Make a copy of the vector, going to chg its value
+				s = qa[3],						//Save Quaternion Scalar (W)
+				d = Vec3.dot(q,v),	// U DOT V
+				dq = Vec3.dot(q,q),	// U DOT U
+				cqv = Vec3.cross(q,v,[0,0,0]);	// Cross Product for Q,V
+
+			Vec3.scale(q,	2.0 * d,	q);
+			Vec3.scale(v,	s*s - dq,	v);
+			Vec3.scale(cqv,	2.0 * s,	cqv);
+
+			out = out || new Vec3();
+			out[0] = q[0] + v[0] + cqv[0];
+			out[1] = q[1] + v[1] + cqv[1];
+			out[2] = q[2] + v[2] + cqv[2];
+			return out;
+		}
+
+		//AXIS MUST BE NORMALIZED.
+		//mult(this, setAxisAngle(axis, angle) )
+		static mulAxisAngle(q, axis, angle, out = null){
+			var ax	= q[0],	
+				ay	= q[1],
+				az	= q[2],
+				aw	= q[3],
+				
+				halfAngle = angle * .5,
+				s	= Math.sin(halfAngle),
+				bx	= axis[0] * s,	//New Quat based on axis and angle
+				by	= axis[1] * s, 
+				bz	= axis[2] * s,
+				bw	= Math.cos(halfAngle);
+
+			//Do quat.mult(a,b);
+			out		= out || q;
+			out[0]	= ax * bw + aw * bx + ay * bz - az * by;
+			out[1]	= ay * bw + aw * by + az * bx - ax * bz;
+			out[2]	= az * bw + aw * bz + ax * by - ay * bx;
+			out[3]	= aw * bw - ax * bx - ay * by - az * bz;
+			return out;
+		}
+
+		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
+		static invert(a,out) {
+			let a0	= a[0],
+				a1	= a[1],
+				a2	= a[2],
+				a3	= a[3],
+				dot	= a0*a0 + a1*a1 + a2*a2 + a3*a3;
+			
+			// TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
+			if(dot == 0){ out[0] = out[1] = out[2] = out[3] = 0; }
+
+			let invDot = dot ? 1.0/dot : 0;
+			out		= out || new Quaternion();
+			out[0]	= -a0*invDot;
+			out[1]	= -a1*invDot;
+			out[2]	= -a2*invDot;
+			out[3]	= a3*invDot;
+			return out;
+		}
+
 		static lerp( a, b, t, out ){
 			var ax = a[0],
 				ay = a[1],
@@ -532,7 +537,6 @@ class Quaternion extends Float32Array{
 			return out;
 		}
 
-
 		static slerp(a, b, t, out=null) {
 			// benchmarks:
 			//    http://jsperf.com/quaternion-slerp-implementations
@@ -576,106 +580,104 @@ class Quaternion extends Float32Array{
 		}
 
 
+	////////////////////////////////////////////////////////////////////
+	// STATIC TRANSFORMATIONS
+	////////////////////////////////////////////////////////////////////
+
 		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
-		static invert(a,out) {
-			let a0	= a[0],
-				a1	= a[1],
-				a2	= a[2],
-				a3	= a[3],
-				dot	= a0*a0 + a1*a1 + a2*a2 + a3*a3;
-			
-			// TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
-			if(dot == 0){ out[0] = out[1] = out[2] = out[3] = 0; }
+		static rotateX(q, rad, out = null){
+			out = out || q;
+			rad *= 0.5; 
 
-			let invDot = dot ? 1.0/dot : 0;
-			out		= out || new Quaternion();
-			out[0]	= -a0*invDot;
-			out[1]	= -a1*invDot;
-			out[2]	= -a2*invDot;
-			out[3]	= a3*invDot;
+			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
+				bx = Math.sin(rad), bw = Math.cos(rad);
+
+			out[0] = ax * bw + aw * bx;
+			out[1] = ay * bw + az * bx;
+			out[2] = az * bw - ay * bx;
+			out[3] = aw * bw - ax * bx;
 			return out;
 		}
 
-		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js#L305
-		static fromMat3(m, out){
-			// Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
-			// article "Quaternion Calculus and Fast Animation".
-			let fRoot, fTrace = m[0] + m[4] + m[8];
-
-			if( fTrace > 0.0 ){
-				// |w| > 1/2, may as well choose w > 1/2
-				fRoot	= Math.sqrt( fTrace + 1.0 );  // 2w
-				out[3]	= 0.5 * fRoot;
-				
-				fRoot	= 0.5 / fRoot;  // 1/(4w)
-				out[0]	= (m[5]-m[7])*fRoot;
-				out[1]	= (m[6]-m[2])*fRoot;
-				out[2]	= (m[1]-m[3])*fRoot;
-			}else{
-				// |w| <= 1/2
-				let i = 0;
-
-				if ( m[4] > m[0] )		i = 1;
-				if ( m[8] > m[i*3+i] )	i = 2;
-				
-				let j = (i+1) % 3;
-				let k = (i+2) % 3;
+		static rotateY(q, rad, out = null) {
+			out = out || q;
+			rad *= 0.5; 
 
-				fRoot	= Math.sqrt( m[i*3+i] - m[j*3+j] - m[k*3+k] + 1.0);
-				out[i]	= 0.5 * fRoot;
+			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
+				by = Math.sin(rad), bw = Math.cos(rad);
 
-				fRoot	= 0.5 / fRoot;
-				out[3]	= ( m[j*3+k] - m[k*3+j] ) * fRoot;
-				out[j]	= ( m[j*3+i] + m[i*3+j] ) * fRoot;
-				out[k]	= ( m[k*3+i] + m[i*3+k] ) * fRoot;
-			}
+			out[0] = ax * bw - az * by;
+			out[1] = ay * bw + aw * by;
+			out[2] = az * bw + ax * by;
+			out[3] = aw * bw - ay * by;
 			return out;
 		}
 
-		//AXIS MUST BE NORMALIZED.
-		//mult(this, setAxisAngle(axis, angle) )
-		static mulAxisAngle(q, axis, angle, out = null){
-			var ax	= q[0],	
-				ay	= q[1],
-				az	= q[2],
-				aw	= q[3],
-				
-				halfAngle = angle * .5,
-				s	= Math.sin(halfAngle),
-				bx	= axis[0] * s,	//New Quat based on axis and angle
-				by	= axis[1] * s, 
-				bz	= axis[2] * s,
-				bw	= Math.cos(halfAngle);
+		static rotateZ(q, rad, out = null){
+			out = out || q;
+			rad *= 0.5; 
 
-			//Do quat.mult(a,b);
-			out		= out || q;
-			out[0]	= ax * bw + aw * bx + ay * bz - az * by;
-			out[1]	= ay * bw + aw * by + az * bx - ax * bz;
-			out[2]	= az * bw + aw * bz + ax * by - ay * bx;
-			out[3]	= aw * bw - ax * bx - ay * by - az * bz;
+			var ax = q[0], ay = q[1], az = q[2], aw = q[3],
+				bz = Math.sin(rad),
+				bw = Math.cos(rad);
+
+			out[0] = ax * bw + ay * bz;
+			out[1] = ay * bw - ax * bz;
+			out[2] = az * bw + aw * bz;
+			out[3] = aw * bw - az * bz;
 			return out;
 		}
+}
 
 
-		static axisAngle(axis, angle, out=null){ //AXIS MUST BE NORMALIZED.
-			let halfAngle	= angle * .5,
-				s			= Math.sin(halfAngle);
+////////////////////////////////////////////////////////////////////
+// CONSTANTS
+////////////////////////////////////////////////////////////////////
+Quaternion.ZERO = new Quaternion();
 
-			out = out || new Quaternion();
-			out[0] = axis[0] * s;
-			out[1] = axis[1] * s;
-			out[2] = axis[2] * s;
-			out[3] = Math.cos(halfAngle);
 
-			return out;
-		}
-	//endregion
+//#############################################################################
+export default Quaternion;
+
+
+
+//https://github.com/libgdx/libgdx/blob/master/gdx/src/com/badlogic/gdx/math/Quaternion.java
+//http://physicsforgames.blogspot.com/2010/03/quaternion-tricks.html
+//http://physicsforgames.blogspot.com/2010/02/quaternions.html
+/*
+Here is a function that will give you the rotation quaternion that will rotate some initial vector into some final vector
+Quat getRotationQuat(const Vector& from, const Vector& to)
+{
+     Quat result;
+
+     Vector H = VecAdd(from, to);
+     H = VecNormalize(H);
+
+     result.w = VecDot(from, H);
+     result.x = from.y*H.z - from.z*H.y;
+     result.y = from.z*H.x - from.x*H.z;
+     result.z = from.x*H.y - from.y*H.x;
+     return result;
 }
 
-Quaternion.ZERO = new Quaternion();
+Vector rotateVector(const Vector& v, const Quat& q)
+{
+     Vector result;
+     float x1 = q.y*v.z - q.z*v.y;
+     float y1 = q.z*v.x - q.x*v.z;
+     float z1 = q.x*v.y - q.y*v.x;
 
-export default Quaternion;
+     float x2 = q.w*x1 + q.y*z1 - q.z*y1;
+     float y2 = q.w*y1 + q.z*x1 - q.x*z1;
+     float z2 = q.w*z1 + q.x*y1 - q.y*x1;
+
+     result.x = v.x + 2.0f*x2;
+     result.y = v.y + 2.0f*y2;
+     result.z = v.z + 2.0f*z2;
 
+     return result;
+}
+*/
 
 /*
 
@@ -702,5 +704,16 @@ export default Quaternion;
             res.z = (xz - wy) * point.x + (yz + wx) * point.y + (1F - (xx + yy)) * point.z;
             return res;
 }
+*/
 
-*/
\ No newline at end of file
+/* Doesn't seem to work well to rotate a vector
+static mulVec3(q, v, out=null){
+	var ax = q[0], ay = q[1], az = q[2], aw = q[3],
+		bx = v[0], by = v[1], bz = v[2];
+
+	out = out || new Vec3();
+	out[0] = ax + aw * bx + ay * bz - az * by;
+	out[1] = ay + aw * by + az * bx - ax * bz;
+	out[2] = az + aw * bz + ax * by - ay * bx;
+	return out;
+} */
\ No newline at end of file
diff --git a/fungi/maths/Vec3.js b/fungi/maths/Vec3.js
index 8f60c16..ce5212f 100644
--- a/fungi/maths/Vec3.js
+++ b/fungi/maths/Vec3.js
@@ -1,6 +1,8 @@
+
 class Vec3 extends Float32Array{
 	constructor(ini){
 		super(3);
+
 		if(ini instanceof Vec3 || (ini && ini.length == 3)){
 			this[0] = ini[0]; this[1] = ini[1]; this[2] = ini[2];
 		}else if(arguments.length == 3){
@@ -10,8 +12,10 @@ class Vec3 extends Float32Array{
 		}
 	}
 
-	//----------------------------------------------
-	//region Getters and Setters
+	////////////////////////////////////////////////////////////////////
+	// GETTER - SETTERS
+	////////////////////////////////////////////////////////////////////
+
 		set(x,y,z){ this[0] = x; this[1] = y; this[2] = z; return this;}
 
 		get x(){ return this[0]; }	set x(val){ this[0] = val; }
@@ -48,40 +52,52 @@ class Vec3 extends Float32Array{
 			return x*x + y*y + z*z;
 		}
 
-		normalize(out){
-			var mag = Math.sqrt( this[0]*this[0] + this[1]*this[1] + this[2]*this[2] );
-			if(mag == 0) return this;
 
+	////////////////////////////////////////////////////////////////////
+	// INSTANCE OPERATORS
+	////////////////////////////////////////////////////////////////////
+		add(v,out){
 			out = out || this;
-			out[0] = this[0] / mag;
-			out[1] = this[1] / mag;
-			out[2] = this[2] / mag;
-
+			out[0] = this[0] + v[0];
+			out[1] = this[1] + v[1];
+			out[2] = this[2] + v[2];
 			return out;
 		}
 
-		//When values are very small, like less then 0.000001, just make it zero.
-		nearZero(out){
+		sub(v,out){
 			out = out || this;
+			out[0] = this[0] - v[0];
+			out[1] = this[1] - v[1];
+			out[2] = this[2] - v[2];
+			return out;
+		}
 
-			if(Math.abs(out[0]) <= 1e-6) out[0] = 0;
-			if(Math.abs(out[1]) <= 1e-6) out[1] = 0;
-			if(Math.abs(out[2]) <= 1e-6) out[2] = 0;
+		mul(v,out){
+			out = out || this;
+			out[0] = this[0] * v[0];
+			out[1] = this[1] * v[1];
+			out[2] = this[2] * v[2];
 
 			return out;
 		}
 
-		invert(out){
+		div(v,out){
 			out = out || this;
-			out[0] = -this[0];
-			out[1] = -this[1];
-			out[2] = -this[2];
+			out[0] = (v[0] != 0)? this[0] / v[0] : 0;
+			out[1] = (v[1] != 0)? this[1] / v[1] : 0;
+			out[2] = (v[2] != 0)? this[2] / v[2] : 0;
+
 			return out;
 		}
-	//endregion
 
-	//----------------------------------------------
-	//region Methods
+		divInvScale(v,out){
+			out = out || this;
+			out[0] = (this[0] != 0)? v / this[0] : 0;
+			out[1] = (this[1] != 0)? v / this[1] : 0;
+			out[2] = (this[2] != 0)? v / this[2] : 0;
+			return out;
+		}	
+
 		scale(v,out){
 			out = out || this;
 			out[0] = this[0] * v;
@@ -98,57 +114,50 @@ class Vec3 extends Float32Array{
 			return out;
 		}
 
-		mul(v,out){
+		abs(v,out){
 			out = out || this;
-			out[0] = this[0] * v[0];
-			out[1] = this[1] * v[1];
-			out[2] = this[2] * v[2];
-
+			out[0] = Math.abs( this[0] );
+			out[1] = Math.abs( this[1] );
+			out[2] = Math.abs( this[2] );
 			return out;
 		}
 
-		add(v,out){
+		//When values are very small, like less then 0.000001, just make it zero.
+		nearZero(out){
 			out = out || this;
-			out[0] = this[0] + v[0];
-			out[1] = this[1] + v[1];
-			out[2] = this[2] + v[2];
-			return out;
-		}
 
-		sub(v,out){
-			out = out || this;
-			out[0] = this[0] - v[0];
-			out[1] = this[1] - v[1];
-			out[2] = this[2] - v[2];
+			if(Math.abs(out[0]) <= 1e-6) out[0] = 0;
+			if(Math.abs(out[1]) <= 1e-6) out[1] = 0;
+			if(Math.abs(out[2]) <= 1e-6) out[2] = 0;
+
 			return out;
 		}
 
-		div(v,out){
+		invert(out){
 			out = out || this;
-			out[0] = (v[0] != 0)? this[0] / v[0] : 0;
-			out[1] = (v[1] != 0)? this[1] / v[1] : 0;
-			out[2] = (v[2] != 0)? this[2] / v[2] : 0;
-
+			out[0] = -this[0];
+			out[1] = -this[1];
+			out[2] = -this[2];
 			return out;
 		}
 
-		divInvScale(v,out){
-			out = out || this;
-			out[0] = (this[0] != 0)? v / this[0] : 0;
-			out[1] = (this[1] != 0)? v / this[1] : 0;
-			out[2] = (this[2] != 0)? v / this[2] : 0;
-			return out;
-		}	
+		normalize(out){
+			var mag = Math.sqrt( this[0]*this[0] + this[1]*this[1] + this[2]*this[2] );
+			if(mag == 0) return this;
 
-		abs(v,out){
 			out = out || this;
-			out[0] = Math.abs( this[0] );
-			out[1] = Math.abs( this[1] );
-			out[2] = Math.abs( this[2] );
+			out[0] = this[0] / mag;
+			out[1] = this[1] / mag;
+			out[2] = this[2] / mag;
+
 			return out;
 		}
 
 
+	////////////////////////////////////////////////////////////////////
+	// TRANSFORMATIONS
+	////////////////////////////////////////////////////////////////////
+		
 		transformMat3(m,out){
 			var x = this[0], y = this[1], z = this[2];
 			out = out || this;
@@ -208,17 +217,11 @@ class Vec3 extends Float32Array{
 			out[2] = this[2] * tMin1 + v[2] * t;
 			return out;
 		}
-	//endregion
 
-	//----------------------------------------------
-	//region Static
-		//static scalarRev(v,s,out){ //TODO, Is this even needed?
-		//	out = out || new Vec3();
-		//	out[0] = s * v[0];
-		//	out[1] = s * v[1];
-		//	out[2] = s * v[2];
-		//	return out;
-		//}
+
+	////////////////////////////////////////////////////////////////////
+	// STATIC OPERATORS
+	////////////////////////////////////////////////////////////////////
 
 		static add(a, b, out){ 
 			out = out || new Vec3();
@@ -227,6 +230,7 @@ class Vec3 extends Float32Array{
 			out[2] = a[2] + b[2];
 			return out;
 		}
+
 		static sub(a, b, out){ 
 			out = out || new Vec3();
 			out[0] = a[0] - b[0];
@@ -234,6 +238,7 @@ class Vec3 extends Float32Array{
 			out[2] = a[2] - b[2];
 			return out;
 		}
+
 		static mul(a, b, out){
 			out = out || new Vec3();
 			out[0] = a[0] * b[0];
@@ -241,6 +246,7 @@ class Vec3 extends Float32Array{
 			out[2] = a[2] * b[2];
 			return out;
 		}
+
 		static div(a,b,out){
 			out = out || new Vec3();
 			out[0] = (b[0] != 0)? a[0] / b[0] : 0;
@@ -248,6 +254,7 @@ class Vec3 extends Float32Array{
 			out[2] = (b[2] != 0)? a[2] / b[2] : 0;
 			return out;
 		}
+
 		static scale(v,s,out){
 			out	= out || new Vec3();
 			out[0] = v[0] * s;
@@ -296,17 +303,6 @@ class Vec3 extends Float32Array{
 			return out;
 		}
 
-		static lerp(a, b, t, out){
-			out = out || new Vec3();
-			let ax = a[0],
-				ay = a[1],
-				az = a[2];
-			out[0] = ax + t * (b[0] - ax);
-			out[1] = ay + t * (b[1] - ay);
-			out[2] = az + t * (b[2] - az);
-			return out;
-		}
-
 		//https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/vec3.js#L514
 		static transformQuat(a, q, out) {
 			// benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed
@@ -340,13 +336,6 @@ class Vec3 extends Float32Array{
 			return out;
 		}
 
-		static createArray(len){
-			var i, ary = new Array(len);
-			for(i=0; i < len; i++) ary[i] = new Vec3();
-			return ary;
-		}
-
-
 		//When values are very small, like less then 0.000001, just make it zero.
 		static nearZero(v, out){
 			out = out || new Vec3();
@@ -358,6 +347,17 @@ class Vec3 extends Float32Array{
 			return out;
 		}
 
+		static lerp(a, b, t, out){
+			out = out || new Vec3();
+			let ax = a[0],
+				ay = a[1],
+				az = a[2];
+			out[0] = ax + t * (b[0] - ax);
+			out[1] = ay + t * (b[1] - ay);
+			out[2] = az + t * (b[2] - az);
+			return out;
+		}
+
 		//Another Equation for Linear Interpolation : (1 - t) * v0 + t * v1;
 		//Todo, see if this one work better then whats there.
 		/*
@@ -375,12 +375,22 @@ class Vec3 extends Float32Array{
 			return out;
 		}
 		*/
-	//endregion
 
+	////////////////////////////////////////////////////////////////////
+	// MISC
+	////////////////////////////////////////////////////////////////////
+
+		// Create an Array of Vectors
+		static createArray(len){
+			var i, ary = new Array(len);
+			for(i=0; i < len; i++) ary[i] = new Vec3();
+			return ary;
+		}
 }
 
 
-//..........................................
+//########################################################################
+// CONSTANTS
 Vec3.UP			= [0,1,0];
 Vec3.DOWN		= [0,-1,0];
 Vec3.LEFT		= [1,0,0];
@@ -390,7 +400,7 @@ Vec3.BACK		= [0,0,-1];
 Vec3.ZERO		= [0,0,0];
 
 
-//..........................................
+//########################################################################
 export default Vec3;
 
 
@@ -420,4 +430,13 @@ export function bezier(out, a, b, c, d, t) {
 
   return out;
 }
+
+
+		//static scalarRev(v,s,out){ //TODO, Is this even needed?
+		//	out = out || new Vec3();
+		//	out[0] = s * v[0];
+		//	out[1] = s * v[1];
+		//	out[2] = s * v[2];
+		//	return out;
+		//}
  */
\ No newline at end of file
diff --git a/Quat_Tips.txt b/notes/Quat_Tips.txt
similarity index 100%
rename from Quat_Tips.txt
rename to notes/Quat_Tips.txt
diff --git a/code.txt b/notes/code.txt
similarity index 99%
rename from code.txt
rename to notes/code.txt
index e8671e0..aa122d5 100644
--- a/code.txt
+++ b/notes/code.txt
@@ -80,4 +80,9 @@ class RotationMotor{
 					ary[ ii ]	= t;
 				}
   				return ary;
-			}
\ No newline at end of file
+			}
+
+
+
+
+
diff --git a/notes/ecs.txt b/notes/ecs.txt
new file mode 100644
index 0000000..751052e
--- /dev/null
+++ b/notes/ecs.txt
@@ -0,0 +1,85 @@
+
+
+- Change Entity to no longer have COM, just throw things at the root and create an Info component.
+- Transform is going to be a Data Structure now to make life ezer when dealing with kinematric and heirarchy
+
+
+Transform
+.pos
+.rot
+.scl
+.add()
+.set()
+
+Entity
+.Info[ name ]
+.Node[ local, world, level, parent, child, parentModified, isModified ]
+.Draw[ matrix, vao, mode, material ]
+
+
+
+Fungi
+	Core
+	- Fungi.js
+	- gl.js
+	- Fbo.js
+	- Ubo.js
+	- Vao.js
+	- Shader.js
+	- RenderLoop.js
+	- DynamicBuffer.js
+	- render_test.html
+	
+	Engine
+	  components
+	  - Node.js
+	  - Draw.js
+	  - Camera.js
+	  - Movement.js
+	  system
+	  - Node.js
+	  - Draw.js
+	  - Movement.js
+	  - Render.js
+	  - DynamicVaoSystem.js
+	- Ecs.js
+	- Debug.js
+	- Page.js ??? Api, App Replacement
+
+	Math
+	- Transform.js
+	- Maths.js
+	- Vec2.js
+	- Vec3.js
+	- Axis.js
+	- Quat.js
+	- Mat4.js
+
+	Extra
+	  primatives
+	    - Cube
+	    - Sphere
+	    - Wedge
+	  - Downloader.js
+	  - InputTracker.js
+	  - Geometry.js
+	  - Loader.js
+
+Fungi.Misc
+- Curves.js
+- TestingMovement.js
+- Timing.js
+- NoiseCycle.js
+- GamepadTracker.js
+
+Fungi.Armature
+  shaders
+  - Preview
+- DualQuat.js
+- Axis.js
+- IKChain.js
+- IKChainSolver.js
+- Armature.js
+- ArmatureSystem.js
+- ArmaturePreview.js
+
diff --git a/extra.txt b/notes/extra.txt
similarity index 100%
rename from extra.txt
rename to notes/extra.txt
diff --git a/glsl.txt b/notes/glsl.txt
similarity index 100%
rename from glsl.txt
rename to notes/glsl.txt
diff --git a/ideas_to_try.txt b/notes/ideas_to_try.txt
similarity index 100%
rename from ideas_to_try.txt
rename to notes/ideas_to_try.txt
diff --git a/notes/jsdoc.txt b/notes/jsdoc.txt
new file mode 100644
index 0000000..976672e
--- /dev/null
+++ b/notes/jsdoc.txt
@@ -0,0 +1,26 @@
+/* 
+ * @module fungi/engine/ecs/Node
+ * @file Manages the configuration settings for the widget.
+ * @author Pedro S. <sketchpunk@gmail.com>
+ * @version 1.2.3
+ * @tutorial tutorial-1
+ * @see {@link foo} for further information.
+ * @see {@link http://github.com|GitHub}
+ */
+
+ /*
+TYPES
+{Array.<number>}
+{string}
+{number}
+{boolean}
+{myNamespace.MyClass}
+{Array.<MyClass>} or {MyClass[]}
+{Object.<string, number>} //Key Value Pair
+{?number} // number or null
+{!number} // number, never null
+@param {...number} num
+@param {number} [foo=1] // optional with default value
+@type {number}
+{(number|boolean)} // can be multiple types
+*/
\ No newline at end of file
diff --git a/math_notes.txt b/notes/math_notes.txt
similarity index 100%
rename from math_notes.txt
rename to notes/math_notes.txt
diff --git a/misc_notes.txt b/notes/misc_notes.txt
similarity index 100%
rename from misc_notes.txt
rename to notes/misc_notes.txt
diff --git a/notes/toon_and_rim_dir.txt b/notes/toon_and_rim_dir.txt
new file mode 100644
index 0000000..67862e9
--- /dev/null
+++ b/notes/toon_and_rim_dir.txt
@@ -0,0 +1,140 @@
+Shader "Toon/Lit" {
+	Properties {
+		_Color ("Main Color", Color) = (0.5,0.5,0.5,1)
+		_MainTex ("Base (RGB)", 2D) = "white" {}
+		_Ramp ("Toon Ramp (RGB)", 2D) = "gray" {} 
+	}
+
+	SubShader {
+		Tags { "RenderType"="Opaque" }
+		LOD 200
+		
+CGPROGRAM
+#pragma surface surf ToonRamp
+
+sampler2D _Ramp;
+
+// custom lighting function that uses a texture ramp based
+// on angle between light direction and normal
+#pragma lighting ToonRamp exclude_path:prepass
+inline half4 LightingToonRamp (SurfaceOutput s, half3 lightDir, half atten)
+{
+	#ifndef USING_DIRECTIONAL_LIGHT
+	lightDir = normalize(lightDir);
+	#endif
+	
+	half d = dot (s.Normal, lightDir)*0.5 + 0.5;
+	half3 ramp = tex2D (_Ramp, float2(d,d)).rgb;
+	
+	half4 c;
+	c.rgb = s.Albedo * _LightColor0.rgb * ramp * (atten * 2);
+	c.a = 0;
+	return c;
+}
+
+
+sampler2D _MainTex;
+float4 _Color;
+
+struct Input {
+	float2 uv_MainTex : TEXCOORD0;
+};
+
+void surf (Input IN, inout SurfaceOutput o) {
+	half4 c = tex2D(_MainTex, IN.uv_MainTex) * _Color;
+	o.Albedo = c.rgb;
+	o.Alpha = c.a;
+}
+ENDCG
+
+	} 
+
+	Fallback "Diffuse"
+}
+
+
+//=======================================================
+//=======================================================
+
+
+Shader "Toon/Rim Outline" {
+	Properties {
+		_Color ("Main Color", Color) = (.5,.5,.5,1)
+		_Brightness("Outline Brightness", Range(1,3)) = 2//
+		_OutlineZ("Outline Z", Range(0.01,0.25)) = 0.2//
+		_Outline ("Outline width", Range (.002, 0.03)) = .005
+		_MainTex ("Base (RGB)", 2D) = "white" { }
+		_Ramp("Toon Ramp (RGB)", 2D) = "gray" {}
+	}
+	
+	CGINCLUDE
+	#include "UnityCG.cginc"
+	
+	struct appdata {
+		float4 vertex : POSITION;
+		float3 normal : NORMAL;
+		float2 uv : TEXCOORD0;//
+	};
+
+	struct v2f {
+		float4 pos : SV_POSITION;
+		UNITY_FOG_COORDS(0)
+		fixed4 color : COLOR;
+		float4 screenPos : TEXCOORD0;//
+		float3 lightDir : TEXCOORD1;//
+		
+	};
+	
+	uniform float _Outline,_Brightness, _OutlineZ;//
+	
+	sampler2D _MainTex;
+	
+	v2f vert(appdata v) {
+		v2f o;
+		o.pos = UnityObjectToClipPos(v.vertex);
+		o.screenPos = ComputeScreenPos(o.pos);//
+		float3 outline   = normalize(mul ((float3x3)UNITY_MATRIX_IT_MV,  v.vertex));
+		o.lightDir = normalize(WorldSpaceLightDir(v.vertex));//
+		float2 offset = TransformViewToProjection(outline) + (float2(o.lightDir.x, -o.lightDir.y) * 2);// add the light direction to the offset for rimlight only on the light side
+		float4 tex = tex2Dlod(_MainTex, float4(v.uv.xy, 0, 0));//
+		
+		#ifdef UNITY_Z_0_FAR_FROM_CLIPSPACE //to handle recent standard asset package on older version of unity (before 5.5)
+			o.pos.xy += offset * UNITY_Z_0_FAR_FROM_CLIPSPACE(o.pos.z) * _Outline;//
+			o.pos.z -= _OutlineZ + (o.screenPos.z * 0.04);// push back the outline, instead of culling the front
+			
+		#else
+			o.pos.xy += offset * o.pos.z * _Outline;
+			o.pos.z -= _OutlineZ + (o.screenPos.z * 0.04);
+		#endif
+		o.color = tex * _Brightness;// textured bright outline
+		UNITY_TRANSFER_FOG(o,o.pos);
+		return o;
+	}
+	ENDCG
+
+	SubShader {
+		Tags { "RenderType"="Opaque" }
+		UsePass "Toon/Lit/FORWARD" // replace with your own shader if you dont want the toon shader
+		Pass {
+			Name "OUTLINE"
+			Tags { "LightMode" = "Always" }
+			//Cull Front
+			ZWrite On
+			ColorMask RGB
+			Blend SrcAlpha OneMinusSrcAlpha
+
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			#pragma multi_compile_fog
+			fixed4 frag(v2f i) : SV_Target
+			{
+				UNITY_APPLY_FOG(i.fogCoord, i.color);
+				return i.color ;
+			}
+			ENDCG
+		}
+	}
+	
+	Fallback "Toon/Basic"
+}
\ No newline at end of file
diff --git a/notes/transform.txt b/notes/transform.txt
new file mode 100644
index 0000000..db1e139
--- /dev/null
+++ b/notes/transform.txt
@@ -0,0 +1,332 @@
+http://gabormakesgames.com/blog_transforms_transforms.html
+
+// a = parent transform, b = child (or current) transform
+Transform CombineTransforms(Transform a, Transform b) {
+    Transform out;
+
+    out.scale = a.scale * b.scale;
+    out.rotation = a.rotation * b.rotation;
+
+    out.position = a.rotation * (a.scale * b.position);
+    out.position = a.position + out.position;
+
+    return out;
+}
+
+Transform GetWorldTransform(Transform transform) {
+    Transform worldTransform = transform; // This is acopy, not a reference
+
+    if (transform.parent != NULL) {
+        Transform worldParent = GetWorldTransform(transform.parent);
+
+        // Accumulate scale, Vector * Vector
+        worldTransform.scale = worldParent.scale * worldTransform.scale;
+
+        // Accumulate rotation, Quaternion * Quaternion
+        worldTransform.rotation = worldParent.rotation * worldTransform.rotation;
+
+        // Accumulate position: scale first, Vector * vector
+        worldTransform.position = worldParent.scale * worldTransform.position;
+        // Accumulate position: rotate next, Quaternion * vector
+        worldTransform.position = worldParent.rotation * worldTransform.position;
+        // Accumulate position: transform last, Vector + Vector
+        worldTransform.position = worldParent.position + worldTransform.position;
+    }
+
+    return worldTransform;
+}
+
+Matrix GetWorldMatrix(Transform transform) {
+    Transform worldSpaceTransform = GetWorldTransform(transform);
+    return ToMatrix(worldSpaceTransform);
+}
+
+Quaternion Transform_GetGlobalRotation (Transform t) {
+    Transform worldXForm = GetWorldTransform(t);
+    return worldXForm.rotation;
+}
+
+Vector3 Transform_GetGlobalPosition (Transform t) {
+    Transform worldXForm = GetWorldTransform(t);
+    return worldXForm.position;
+
+}
+
+Vector3 Transform_GetGlobalScale(Transform t) {
+    Transform worldXForm = GetWorldTransform(t);
+    return worldXForm.scale;
+}
+
+//http://gabormakesgames.com/blog_transforms_transform_world.html
+
+World Space Setters
+To set a world space transform component, we have to invert the parent of the transform (in world space) and combine it with the desired world space transform. We can invert a transform local to its-self (not taking the parent into consideration) by first inverting the rotation and scale then applying these to the inverted translation.
+
+Transform LocalInverse(Transform t) {
+    Quaternion invRotation = Inverse(t.rotation);
+
+    Vector3 invScale = Vector3(0, 0, 0);
+    if (t.scale.x != 0) { // Do epsilon comparison here
+        invScale.x = 1.0 / t.scale.x
+    }
+    if (t.scale.y != 0) { // Do epsilon comparison here
+        invScale.y = 1.0 / t.scale.y
+    }
+    if (t.scale.z != 0) { // Do epsilon comparison here
+        invScale.z = 1.0 / t.scale.z
+    }
+
+    Vector3 invTranslation = invRotation * (invScale * (-1 * t.translation));
+
+    Transform result;
+    result.position = invTranslation;
+    result.rotation = invRotation;
+    result.scale = invScale;
+
+    return result;
+}
+Now that we can invert a transform, making a function that sets the position, rotation and scale of a transform in world space becomes trivial. Find the parent's world space transform, invert it and multiply it by the desired world space transform. The resulting transform is in the local space of the parent, as expected.
+
+void SetGlobalSRT(Transform t, Vector3 s, Quaternion r, Vector3 p) {
+    if (t.parent == NULL) {
+        t.rotation = r;
+        t.position = p;
+        t.scale = s;
+        return;
+    }
+
+    var worldParent = GetWorldTransform(t.parent);
+    var invParent = LocalInverse(worldParent);
+
+    Transform worldXForm;
+    worldXForm.position = p;
+    worldXForm.rotation = r;
+    worldXForm.scale = s;
+
+    worldXForm = CombineTransforms(invParent, worldXForm);
+
+    t.position = worldXForm.position;
+    t.rotation = worldXForm.rotation;
+    t.scale = worldXForm.scale;
+}
+Let's make some conveniance functions that only set one component of the transform. To do so find the world space transform, substitute the desired component and call the SetGlobalSRT written above.
+
+void SetGlobalRotation (Transform t, Quaternion rotation) {
+    Transform worldXForm = GetWorldTransform(t);
+    SetGlobalSRT(t, worldXForm.scale, rotation, worldXForm.position);
+}
+
+void SetGlobalPosition (Transform t, Vector3 position) {
+    Transform worldXForm = GetWorldTransform(t);
+    SetGlobalSRT(t, worldXForm.scale, worldXForm.rotation, position);
+}
+
+void SetGlobalScale(Transform t, Vector3 scale) {
+    Transform worldXForm = GetWorldTransform(t);
+    SetGlobalSRT(t, scale, worldXForm.rotation, worldXForm.position);
+}
+
+
+Graphics API's expect the transformation of an object to be passed as a matrix. Therefore, we need a way to convert a Transform structure to a 4x4 Matrix. To do this conversion, first extract the basis vectors from the rotation of the transform. Next, scale the basis vectors by the scale of the transform. Finally, stuff the basis vectors and the position vector into a Matrix. The code below demonstrates how to do this:
+
+Matrix ToMatrix(Transform transform) {
+    // First, extract the rotation basis of the transform
+    Vector x = transform.rotation * Vector(1, 0, 0); // Quat * Vec3 (right vector)
+    Vector y = transform.rotation * Vector(0, 1, 0); // Quat * Vec3 (up vector)
+    Vector z = transform.rotation * Vector(0, 0, 1); // Quat * Vec3 (forward vector)
+    
+    // Next, scale the basis vectors
+    x = x * transform.scale.x; // Vector * float
+    y = y * transform.scale.y; // Vector * float
+    z = z * transform.scale.z; // Vector * float
+
+    // Extract the position of the transform
+    Vector t = transform.position;
+
+    // Create matrix
+    return Matrix(
+        x.x, x.y, x.z, 0, // X basis (& Scale)
+        y.x, y.y, y.z, 0, // Y basis (& scale)
+        z.x, z.y, z.z, 0, // Z basis (& scale)
+        t.x, t.y, t.z, 1  // Position
+    );
+}
+
+
+struct Transform {
+    Transform parent; // Reference
+
+    Vector position;
+    Quaternion rotation;
+    Vector scale;
+}
+
+
+Quaternion GetGlobalRotation(Transform t) {
+    Transform iterator = t.parent
+
+    while (iterator != NULL) {
+        rotation = iterator.rotation * t.rotation;
+        iterator = iterator.parent
+    }
+
+    return rotation;
+}
+
+
+
+Getting Global Position
+The easy way to get the world position of a transform would be to take the last row of the world matrix of the transform. However, we can save a few multiplications by calculating this value without any matrix operations. We need to take the position of the transform and apply it's parents transform to it in the same order as multiplying matrices would:
+
+scale first
+rotate next
+translate last:
+Vector GetGlobalPosition(Transform t) {
+    Vector worldPos = t.position; // Copy, not reference
+
+    Transform iter = t.Parent
+    while (iter != null) {
+        // First apply parent scale
+        worldPos = worldPos * iter.scale // Vec3 * Vec3
+        // Next apply parent rotation
+        worldPos = iter.rotation * worldPos; // Quat * Vec3
+        // Finally apply parent translation
+        worldPos += iter.position; // Vec3 + Vec3
+
+        iter = iter.parent
+    }
+
+    return worldPos;
+}
+
+
+
+Getting Global (lossy) Scale
+The rotation and scale of a parent transform affects the scale of it's child transforms, this can introduce skewing if a parent has a non-uniform scale. Because of this, retrieving the global scale of a transform is difficult. The first step in doing so is to find a 3x3 Matrix that holds both the rotation and scale of the transform. To find this matrix, convert the scale and rotation of the transform into matrices, combine them and recirsivley multiply with the parent transforms rotation and scale matrix.
+
+Matrix3 GetGlobalRotationAndScale(Transform t) {
+    Matrix3 scaleMat = Matrix3(
+        t.scale.x, 0, 0,
+        0, t.scale.y, 0,
+        0, 0, t.scale.z
+    );
+    Matrix3 rotationMat = ToMatrix(t.rotation);
+
+    Matrix3 worldRS = rotationMat * scaleMat;
+
+    // Recursivley concatenate with parent
+    if (t.parent != NULL) {
+        Matrix3 parentRS = GetGlobalRotationAndScale(t.parent);
+        worldRS = parentRS * worldRS;
+    }
+
+    // Return scale rotation
+    return worldRS
+}
+Now that we know the global rotation and scale of the transform, we can remove the rotation component, leaving us with just the scale and skew matrix. To do this, find just the global rotation of the transform, invert that quaternion and turn it into a matrix. This new matrix is the inverse global rotation matrix of the transform. Multiply it with the scale and rotation matrix to remove the rotation component. The main diagonal of the resulting scale and skew matrix is the global lossy scale of the transform.
+
+Vector3 GetGlobalLossyScale(Transform t) {
+    // Find inverse global rotation (rotation only) of transform
+    Quaternion rotation = GetGlobalRotation(t);
+    Matrix3 invRotation = ToMatrix(Inverse(rotation));
+
+    // Find global rotation and scale of transform
+    Matrix3 scaleAndRotation = GetGlobalRotationAndScale(t);
+
+    // Remove global rotation from rotation & scale
+    Matrix3 scaleAndSkew = invRotation * scaleAndRotation; // Mat3 * Mat3
+
+    // Return the main doagonal of the scale & skew matrix
+    return Vector3(scaleAndSkew[0], scaleAndSkew[4], scaleAndSkew[8]);
+}
+
+
+Setting Global Rotation
+Setting the global rotation of a transform is trivial, first find the world space rotation of the transforms parent and invert it. Next move the desired global rotation into the local space of the parent transform by multiplying the inverse of the parents rotation. Assign the result of this multiplication as the local rotation of the transform.
+
+void SetGlobalRotation(Transform t, Quaternion rotation)  {
+    if (t.parent == NULL) {
+        t.rotation = rotation;
+        return
+    }
+
+    Quaternion parentGlobal = GetGlobalRotation(t.parent)
+    Quaternion invParentGlobal = Inverse(parentGlobal);
+
+    t.rotation = invParentGlobal * rotation;
+}
+
+Setting Global Position
+To set the global position of a transform, we need to take the global point and transform it by the inverse of the parent transform (If there is one). We could either find the matrix representation of the global parent transform, invert it and multiply the point by that OR we can do it component wise, like the global position getter. Doing it component wise will save a few multiplications.
+
+To invert a point by a transform, the inverse of each component needs to be applied, in reverse order. Normally you'd transform a point by applying it's scale, rotation then position. To apply the inverse of a transform, apply the inverted position, inverted rotation, then inverted scale.
+
+inverted positon: position * -1
+inverted rotation: quaternion inverse (negative x, y, z)
+inverted scale: 1 / scale
+That was a very long winded explanation, the code is much simpler:
+
+Vector3 InverseTransformPoint(Transform t, Vector3 point) {
+    // Recursive function, apply inverse of parent transform first
+    if (t.parent != NULL) {
+        point = InverseTransformPoint(t.parent, point)
+    }
+
+    // First, apply the inverse translation of the transform
+    point = point - t.position;
+
+    // Next, apply the inverse rotation of the transform
+    Quaternion invRot = Inverse(t.rotation);
+    point =  invRot * point;
+
+    // Finally, apply the inverse scale
+    point = point / t.scale; // Component wise vector division
+
+    return point
+}
+Once we have a function for applying the inverse of a transform to a point, setting the global position of a transform is trivial.
+
+void SetGlobalPosition(Transform t, Vector3 position) {
+    if (t.parent != NULL) {
+        pos = InverseTransformPoint(t.parent, position);
+    }
+
+    t.position = position;
+}
+Setting Global Scale
+Working with global scale is probably the most complicated part of working with a transform hierarchy. Depending on the global basis vectors of the transform, it may contain skew data, not just scale. Because of this, we can't just set global scale. We have to set the entire 3x3 sub matrix where scale data may live.
+
+To set this matrix we need to find the global rotation and scale matrix of the transform, where the scale of this transform isn't taken into account but the scale of all parent transforms is. Invert this matrix, and mulyiply the desired 3x3 matrix by the inverted matrix. The main diagonal of this matrix is the new scale.
+
+void SetGlobalScaleFromRotationScaleMatrix(Transform t, Matrix3 rsMat) {
+    // Reset scale to 1, do this so we can get the  global rotation and scale 
+    // without the scale of this transform but with the scale of all parents
+    t.scale = Vector3(1, 1, 1); 
+
+    // Find inverse global matrix (scale of all parent tranforms, not this one)
+    Matrix3 globalRS = GetGlobalRotationAndScale(t);
+    Matrix3 inverseRS = Inverse(globalRS);
+
+    // Bring the rotation scale matrix into local space
+    Matrix3 localRS = inverseRS * rsMat;
+    
+    // Main diagonal is the new scale
+    t.scale = Vector3(localRS[0], localRS[4], localRS[8]);
+}
+Setting global scale with a 3x3 matrix that also contains rotation data is un-intuitive at best. We can make a simple wrapper function that takes the desired global scaling vector as an argument and constructs the rotation-scale matrix using the current global rotation of the transform:
+
+void SetGlobalScale(Transform t, Vector3 scale) {
+    Quaternion globalRotation = GetGlobalRotation(t)
+
+    var x = globalRotation * Vector3(scale.x, 0, 0);
+    var y = globalRotation * Vector3(0, scale.y, 0);
+    var z = globalRotation * Vector3(0, 0, scale.z);
+    
+    Matrix3 rotationAndScaleMat = Matrix3(
+        x.x, x.y, x.z,
+        y.x, y.y, y.z,
+        z.x, z.y, z.z
+    )
+
+    SetGlobalScaleFromRotationScaleMatrix(t, rotationAndScaleMat);
+}
\ No newline at end of file